> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Alle Einstellungen

> Vollständige Referenz für jeden Claude Code settings.json-Schlüssel: wo jeder hingehört, sein Typ und Standard, sowie ein einsatzbereites Beispiel, mit einem Index aller Schlüssel.

[Zurück zum Index](#all-settings)

Diese Referenzseite listet jeden Schlüssel auf, den Claude Code aus einer Einstellungsdatei liest, sowie die [kurze Gruppe von Schlüsseln](#global-config-settings), die es stattdessen in `~/.claude.json` speichert. Um eine Datei auszuwählen oder die Priorität zu überprüfen, beginnen Sie mit [Einstellungsdateien und Priorität](https://code.claude.com/docs/de/settings.md).

## Einstellungsindex

Jeder Schlüssel unten verlinkt auf seinen Eintrag. Der Geltungsbereich listet die [Dateien](https://code.claude.com/docs/de/settings.md#settings-files-and-who-they-affect) auf, in denen er stehen kann: `Benutzer` ist `~/.claude/settings.json`, `Projekt` ist `.claude/settings.json`, `Lokal` ist `.claude/settings.local.json` und `Verwaltet` ist [das, was Ihre Organisation bereitstellt](https://code.claude.com/docs/de/managed-settings.md). `Jede Datei` bedeutet alle vier, und `Globale Konfiguration` bedeutet [`~/.claude.json`](#global-config-settings).

| Key | Description | Topic | Scope |
| :- | :- | :- | :- |
| [`advisorModel`](#advisormodel) | Legt fest, welches Modell antwortet, wenn Claude das [Advisor-Tool](https://code.claude.com/docs/de/advisor.md) befragt | Modell und Antworten | Jede Datei |
| [`agent`](#agent) | Startet jede Sitzung als benannten [Subagenten](https://code.claude.com/docs/de/sub-agents.md) mit dessen Prompt, Tools und Modell | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`agentPushNotifEnabled`](#agentpushnotifenabled) | Erlaubt Claude, eine [Push-Benachrichtigung an Ihr Smartphone](https://code.claude.com/docs/de/remote-control.md#mobile-push-notifications) zu senden, wenn es dies für angebracht hält | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`allowAllClaudeAiMcps`](#allowallclaudeaimcps) | Lädt die [claude.ai-Konnektoren](https://code.claude.com/docs/de/mcp.md), die Claude Code selbst abruft, zusätzlich zu einer bereitgestellten [`managed-mcp.json`](https://code.claude.com/docs/de/managed-mcp#exclusive-control-with-managed-mcp-json) | MCP | Verwaltet |
| [`allowClaudeInChromeWithManagedMcp`](#allowclaudeinchromewithmanagedmcp) | Lässt den integrierten [Claude in Chrome](https://code.claude.com/docs/de/chrome.md)-Server neben einer bereitgestellten [`managed-mcp.json`](https://code.claude.com/docs/de/managed-mcp#exclusive-control-with-managed-mcp-json) laufen | MCP | Verwaltet |
| [`allowedChannelPlugins`](#allowedchannelplugins) | Ersetzt die Standard-Allowlist der [Channel-Plugins](https://code.claude.com/docs/de/channels.md#restrict-which-channel-plugins-can-run), die Nachrichten senden dürfen | Plugins und Skills | Verwaltet |
| [`allowedHttpHookUrls`](#allowedhttphookurls) | Beschränkt, welche URLs [HTTP-Hooks](https://code.claude.com/docs/de/hooks.md) ansprechen können | Hooks und Automatisierung | Jede Datei |
| [`allowedMcpServers`](#allowedmcpservers) | Legt per Allowlist fest, welche [MCP-Server](https://code.claude.com/docs/de/mcp.md) Benutzer hinzufügen können | MCP | Jede Datei |
| [`allowedProviders`](#allowedproviders) | Beschränkt, welche [API-Anbieter](https://code.claude.com/docs/de/third-party-integrations.md) ein Rechner verwenden darf | Authentifizierung und Anbieter | Verwaltet |
| [`allowManagedHooksOnly`](#allowmanagedhooksonly) | Führt nur die [Hooks](https://code.claude.com/docs/de/hooks.md) aus, die Ihre Organisation bereitstellt | Hooks und Automatisierung | Verwaltet |
| [`allowManagedMcpServersOnly`](#allowmanagedmcpserversonly) | Macht die verwaltete [MCP](https://code.claude.com/docs/de/mcp.md)-Allowlist zur einzigen, die gilt | MCP | Verwaltet |
| [`allowManagedPermissionRulesOnly`](#allowmanagedpermissionrulesonly) | Macht [verwaltete Einstellungen](https://code.claude.com/docs/de/managed-settings.md) zur einzigen Einstellungsquelle für [Berechtigungsregeln](https://code.claude.com/docs/de/permissions.md#managed-settings) | Berechtigungseinstellungen | Verwaltet |
| [`alwaysThinkingEnabled`](#alwaysthinkingenabled) | Schaltet [Extended Thinking](https://code.claude.com/docs/de/model-config.md#extended-thinking) für jede Sitzung aus | Modell und Antworten | Jede Datei |
| [`apiKeyHelper`](#apikeyhelper) | Erzeugt die [API-Anmeldedaten](https://code.claude.com/docs/de/authentication.md#credential-management) mit Ihrem eigenen Befehl | Authentifizierung und Anbieter | Jede Datei |
| [`askUserQuestionTimeout`](#askuserquestiontimeout) | Lässt eine unbeantwortete Frage nach einer Leerlaufzeit [automatisch fortfahren](https://code.claude.com/docs/de/tools-reference.md#question-auto-continue-timeout) | Oberfläche und Terminal | Benutzer oder verwaltet |
| [`appendPlugins`](#appendplugins) | Führt die [Mods](https://code.claude.com/docs/de/plugins/mods/admin.md) Ihrer Organisation nach jedem Mod aus, den ein Benutzer installiert | Plugins und Skills | Benutzer oder verwaltet |
| [`attribution`](#attribution) | Passt die Attribution an, die Claude Code zu Commits und Pull Requests hinzufügt | Git und Attribution | Jede Datei |
| [`attribution.commit`](#attribution-commit) | Ändert oder verbirgt den Trailer, den Claude Code zu Commits hinzufügt | Git und Attribution | Jede Datei |
| [`attribution.pr`](#attribution-pr) | Ändert oder verbirgt die Attributionszeile in Pull-Request-Beschreibungen | Git und Attribution | Jede Datei |
| [`attribution.sessionUrl`](#attribution-sessionurl) | Lässt den claude.ai-Sitzungslink in Commits aus der [Cloud](https://code.claude.com/docs/de/claude-code-on-the-web.md) und aus [Remote Control](https://code.claude.com/docs/de/remote-control.md) weg | Git und Attribution | Jede Datei |
| [`autoCompactEnabled`](#autocompactenabled) | Schaltet die [automatische Komprimierung](https://code.claude.com/docs/de/context-window.md) aus oder ein | Memory und Kontext | Jede Datei |
| [`autoCompactWindow`](#autocompactwindow) | Legt fest, wie voll der Kontext werden darf, bevor Claude Code [komprimiert](https://code.claude.com/docs/de/context-window.md) | Memory und Kontext | Jede Datei |
| [`autoConnectIde`](#autoconnectide) | Verbindet sich aus einem externen Terminal automatisch mit einer laufenden [VS Code](https://code.claude.com/docs/de/vs-code.md)- oder [JetBrains](https://code.claude.com/docs/de/jetbrains.md#from-external-terminals)-IDE | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`autoContinueAtUsageLimit`](#autocontinueatusagelimit) | Wartet in der geöffneten Sitzung und [setzt die Aufgabe automatisch fort](https://code.claude.com/docs/de/interactive-mode.md#wait-for-a-usage-limit-to-reset), nachdem ein claude.ai-Nutzungslimit zurückgesetzt wurde | Oberfläche und Terminal | Benutzer oder verwaltet |
| [`autoInstallIdeExtension`](#autoinstallideextension) | Deaktiviert die automatische Installation der [IDE-Erweiterung](https://code.claude.com/docs/de/vs-code.md#install-the-extension) aus einem VS Code-Terminal heraus | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`autoMemoryDirectory`](#automemorydirectory) | Speichert [Auto-Memory](https://code.claude.com/docs/de/memory.md#auto-memory) in einem Verzeichnis Ihrer Wahl | Memory und Kontext | Jede Datei |
| [`autoMemoryEnabled`](#automemoryenabled) | Schaltet [Auto-Memory](https://code.claude.com/docs/de/memory.md#auto-memory) aus oder ein | Memory und Kontext | Jede Datei |
| [`autoMode`](#automode) | Fügt dem Klassifikator des [Auto-Modus](https://code.claude.com/docs/de/permission-modes.md#eliminate-prompts-with-auto-mode) eigene allow- und deny-Regeln hinzu | Berechtigungseinstellungen | Benutzer oder verwaltet |
| [`autoMode.classifyAllShell`](#automode-classifyallshell) | Leitet jeden Shell-Befehl durch den [Klassifikator des Auto-Modus](https://code.claude.com/docs/de/permission-modes.md#what-the-classifier-blocks-by-default), auch solche, auf die eine eng gefasste allow-Regel zutrifft | Berechtigungseinstellungen | Benutzer oder verwaltet |
| [`autoScrollEnabled`](#autoscrollenabled) | [Folgt neuer Ausgabe](https://code.claude.com/docs/de/fullscreen.md#auto-follow) bis ans Ende im Vollbild-Rendering | Oberfläche und Terminal | Jede Datei |
| [`autoUpdatesChannel`](#autoupdateschannel) | Folgt dem stabilen [Release-Kanal](https://code.claude.com/docs/de/setup.md#configure-release-channel) statt latest | Updates und Versionierung | Jede Datei |
| [`availableModels`](#availablemodels) | [Beschränkt, welche Modelle](https://code.claude.com/docs/de/model-config.md#restrict-model-selection) ausgewählt werden können | Modell und Antworten | Jede Datei |
| [`availableModelsMatch`](#availablemodelsmatch) | Sorgt dafür, dass jeder Modell-ID-Eintrag in `availableModels` [nur die genannte Version zulässt](https://code.claude.com/docs/de/model-config.md#block-specific-models-or-versions) | Modell und Antworten | Verwaltet |
| [`awaySummaryEnabled`](#awaysummaryenabled) | Deaktiviert die [Sitzungszusammenfassung](https://code.claude.com/docs/de/interactive-mode.md#session-recap), die angezeigt wird, wenn Sie zum Terminal zurückkehren | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`awsAuthRefresh`](#awsauthrefresh) | Aktualisiert abgelaufene [Bedrock-Anmeldedaten](https://code.claude.com/docs/de/amazon-bedrock.md#advanced-credential-configuration) in `.aws` mit Ihrem eigenen Befehl | Authentifizierung und Anbieter | Jede Datei |
| [`awsCredentialExport`](#awscredentialexport) | Liefert [Bedrock-Anmeldedaten](https://code.claude.com/docs/de/amazon-bedrock.md#advanced-credential-configuration) als JSON aus Ihrem eigenen Befehl | Authentifizierung und Anbieter | Jede Datei |
| [`axScreenReader`](#axscreenreader) | Rendert [screenreaderfreundliche Ausgabe](https://code.claude.com/docs/de/accessibility.md) | Oberfläche und Terminal | Benutzer oder verwaltet |
| [`bashEditDiffEnabled`](#basheditdiffenabled) | Erfasst in jedem Berechtigungsmodus die [Dateien, die sich während der Ausführung eines Bash-Befehls geändert haben](https://code.claude.com/docs/de/hooks.md#bash) | Oberfläche und Terminal | Benutzer oder verwaltet |
| [`bashOutputMaxChars`](#bashoutputmaxchars) | Legt fest, wie viel der [Ausgabe](https://code.claude.com/docs/de/tools-reference.md#output-limits) eines erfolgreichen Befehls Claude direkt erhält | Memory und Kontext | Jede Datei |
| [`blockedMarketplaces`](#blockedmarketplaces) | Blockiert [Plugin-Marketplace](https://code.claude.com/docs/de/plugins/overview.md)-Quellen für Ihre Organisation | Plugins und Skills | Verwaltet |
| [`browserExternalPageTools`](#browserexternalpagetools) | Hält Claudes Tools im Browser-Bereich von [Desktop](https://code.claude.com/docs/de/desktop.md) von externen Seiten fern | Tools | Verwaltet |
| [`channelsEnabled`](#channelsenabled) | Erlaubt [Channels](https://code.claude.com/docs/de/channels.md#enable-channels-for-your-organization) für Ihre Organisation | Plugins und Skills | Verwaltet |
| [`claudeInChromeDefaultEnabled`](#claudeinchromedefaultenabled) | Aktiviert die [Chrome-Integration](https://code.claude.com/docs/de/chrome.md) beim Start einer Sitzung, in der interaktiven CLI und in der VS Code-Erweiterung | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`claudeMd`](#claudemd) | Fügt organisationsweite [CLAUDE.md](https://code.claude.com/docs/de/memory.md#deploy-organization-wide-claude-md)-Anweisungen aus verwalteten Einstellungen ein | Memory und Kontext | Verwaltet |
| [`claudeMdExcludes`](#claudemdexcludes) | Überspringt bestimmte [CLAUDE.md](https://code.claude.com/docs/de/memory.md#exclude-specific-claude-md-files)-Dateien beim Laden des Memory | Memory und Kontext | Jede Datei |
| [`cleanupPeriodDays`](#cleanupperioddays) | Legt fest, wie viele Tage Claude Code [Transkripte](https://code.claude.com/docs/de/data-usage.md#data-retention) aufbewahrt, bevor sie gelöscht werden | Datenschutz und Telemetrie | Jede Datei |
| [`companyAnnouncements`](#companyannouncements) | Zeigt beim Start die Ankündigungen Ihrer Organisation an | Oberfläche und Terminal | Jede Datei |
| [`copyFullResponse`](#copyfullresponse) | Sorgt dafür, dass [`/copy`](https://code.claude.com/docs/de/commands) die vollständige Antwort kopiert, ohne die Auswahl anzuzeigen | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`copyOnSelect`](#copyonselect) | Deaktiviert das automatische Kopieren von Text, den Sie im [Vollbild-Rendering](https://code.claude.com/docs/de/fullscreen.md#use-the-mouse) und in der Agentenansicht mit der Maus auswählen | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`crossSessionInbound`](#crosssessioninbound) | Legt fest, ob Claude Code [Nachrichten aus Ihren anderen Sitzungen](https://code.claude.com/docs/de/cross-session-messaging.md#control-inbound-messages) zustellt, einen Hinweis anzeigt, ohne sie zuzustellen, oder sie ablehnt | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`defaultShell`](#defaultshell) | Legt fest, ob Bash oder PowerShell die Shell-Befehle ausführt, die Sie mit dem [`!`-Präfix](https://code.claude.com/docs/de/interactive-mode#shell-mode-with-prefix) eingeben | Oberfläche und Terminal | Jede Datei |
| [`defaultToAgentsView`](#defaulttoagentsview) | Öffnet die [Agentenansicht](https://code.claude.com/docs/de/agent-view.md) statt einer neuen Konversation, wenn Sie `claude` ohne Argumente ausführen | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`deniedMcpServers`](#deniedmcpservers) | Blockiert bestimmte [MCP-Server](https://code.claude.com/docs/de/mcp.md) nach URL, Befehl oder Name | MCP | Jede Datei |
| [`deniedModels`](#deniedmodels) | [Blockiert bestimmte Modelle](https://code.claude.com/docs/de/model-config.md#block-specific-models-or-versions), auch solche, die `availableModels` zulässt | Modell und Antworten | Verwaltet |
| [`desktopSessionCleanupPeriodDays`](#desktopsessioncleanupperioddays) | Legt eine Altersgrenze in Tagen für [Transkripte von Claude Desktop und Cowork](https://code.claude.com/docs/de/claude-directory.md#cleaned-up-automatically) fest | Datenschutz und Telemetrie | Benutzer oder verwaltet |
| [`dialogExpiry`](#dialogexpiry) | Legt fest, wie lange Claude Code darauf wartet, dass [Remote Control](https://code.claude.com/docs/de/remote-control.md) oder ein SDK-Host einen weitergeleiteten Dialog beantwortet, bevor der Dialog abgebrochen wird | Oberfläche und Terminal | Benutzer oder verwaltet |
| [`diffTool`](#difftool) | Legt fest, ob Claudes vorgeschlagene Dateiänderungen im Diff-Viewer von [VS Code](https://code.claude.com/docs/de/vs-code.md) oder [JetBrains](https://code.claude.com/docs/de/jetbrains.md#features) geöffnet werden oder im Terminal bleiben | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`disableAgentView`](#disableagentview) | Deaktiviert Hintergrund-Agenten und die [Agentenansicht](https://code.claude.com/docs/de/agent-view.md) | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`disableAllHooks`](#disableallhooks) | Deaktiviert [Hooks](https://code.claude.com/docs/de/hooks.md), eine benutzerdefinierte [Statuszeile](https://code.claude.com/docs/de/statusline.md) und einen benutzerdefinierten Befehl für [`@`-Dateivorschläge](https://code.claude.com/docs/de/interactive-mode#quick-commands) auf einmal | Hooks und Automatisierung | Jede Datei |
| [`disableArtifact`](#disableartifact) | Veraltet; verwenden Sie `enableArtifact`, um das [Artifact-Tool](https://code.claude.com/docs/de/artifacts.md) zu deaktivieren | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`disableAutoMode`](#disableautomode) | Entfernt den [Auto-Modus](https://code.claude.com/docs/de/permission-modes.md#eliminate-prompts-with-auto-mode) aus dem Wechsel der Berechtigungsmodi | Berechtigungseinstellungen | Jede Datei |
| [`disableBrowserExternalNavigation`](#disablebrowserexternalnavigation) | Beschränkt den Browser-Bereich von [Desktop](https://code.claude.com/docs/de/desktop.md) für Personen und Claude auf localhost | Tools | Verwaltet |
| [`disableBundledSkills`](#disablebundledskills) | Deaktiviert die mit Claude Code mitgelieferten [Skills](https://code.claude.com/docs/de/skills.md#bundled-skills) und [Workflows](https://code.claude.com/docs/de/workflows.md) | Plugins und Skills | Jede Datei |
| [`disableClaudeAiConnectors`](#disableclaudeaiconnectors) | Deaktiviert [claude.ai-Konnektoren](https://code.claude.com/docs/de/mcp.md#disable-claude-ai-connectors), sodass Claude Code sie nicht abruft | MCP | Jede Datei |
| [`disableCommandPluginSources`](#disablecommandpluginsources) | Blockiert [Plugins](https://code.claude.com/docs/de/plugins/overview.md), die durch Ausführen eines vom Marketplace deklarierten Befehls installiert werden | Plugins und Skills | Verwaltet |
| [`disableDeepLinkRegistration`](#disabledeeplinkregistration) | Verhindert, dass Claude Code den [`claude-cli://`-Handler](https://code.claude.com/docs/de/deep-links) registriert | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`disableDesktopLocalSessions`](#disabledesktoplocalsessions) | Deaktiviert [Desktop-Code-Sitzungen](https://code.claude.com/docs/de/desktop.md#local-sessions-on-managed-devices), die auf dem Gerät laufen; SSH zu anderen Hosts und die Cloud bleiben verfügbar | Remote, Desktop und Benachrichtigungen | Verwaltet |
| [`disabledMcpjsonServers`](#disabledmcpjsonservers) | Lehnt bestimmte Server aus der [`.mcp.json`](https://code.claude.com/docs/de/mcp#project-scope) eines Projekts ab | MCP | Jede Datei |
| [`disableMobileSimulatorTools`](#disablemobilesimulatortools) | Blockiert Claudes Tools im iOS-Simulator-Bereich von [Desktop](https://code.claude.com/docs/de/desktop.md) | Tools | Verwaltet |
| [`disableRemoteControl`](#disableremotecontrol) | Deaktiviert [Remote Control](https://code.claude.com/docs/de/remote-control.md) überall, wo es gestartet werden kann | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`disableSideloadFlags`](#disablesideloadflags) | Lehnt die CLI-Flags ab, die [Plugins](https://code.claude.com/docs/de/plugins/overview.md), [Subagenten](https://code.claude.com/docs/de/sub-agents.md) und [MCP-Server](https://code.claude.com/docs/de/mcp.md) per Sideloading laden | Enterprise und verwaltete Einstellungen | Verwaltet |
| [`disableSkillShellExecution`](#disableskillshellexecution) | Verhindert, dass [Skills](https://code.claude.com/docs/de/skills.md) und benutzerdefinierte Befehle Inline-Shell ausführen | Plugins und Skills | Jede Datei |
| [`disableWorkflows`](#disableworkflows) | Deaktiviert [dynamische Workflows](https://code.claude.com/docs/de/workflows.md) für alle; verwenden Sie `enableWorkflows` für sich selbst | Hooks und Automatisierung | Jede Datei |
| [`editorMode`](#editormode) | Verwendet [Vim-Tastenbelegungen](https://code.claude.com/docs/de/interactive-mode.md#vim-editor-mode) in der Eingabe | Oberfläche und Terminal | Jede Datei |
| [`effortLevel`](#effortlevel) | Legt eine Standard-[Effort-Stufe](https://code.claude.com/docs/de/model-config.md#adjust-effort-level) für Modelle ohne eigene gespeicherte Stufe fest | Modell und Antworten | Jede Datei |
| [`emojiCompletionEnabled`](#emojicompletionenabled) | Deaktiviert [`:shortcode:`-Emoji-Vorschläge und -Ersetzung](https://code.claude.com/docs/de/interactive-mode#emoji-shortcodes) in der Prompt-Eingabe | Oberfläche und Terminal | Jede Datei |
| [`enableAllProjectMcpServers`](#enableallprojectmcpservers) | Genehmigt jeden Server in [`.mcp.json`](https://code.claude.com/docs/de/mcp#project-server-approvals-and-workspace-trust)-Dateien von Projekten ohne Nachfrage | MCP | Jede Datei |
| [`enableArtifact`](#enableartifact) | Deaktiviert das [Artifact-Tool](https://code.claude.com/docs/de/artifacts.md) mit `false` in einer beliebigen Datei; keine Datei kann es wieder aktivieren | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`enabledMcpjsonServers`](#enabledmcpjsonservers) | Genehmigt bestimmte Server aus der [`.mcp.json`](https://code.claude.com/docs/de/mcp#project-server-approvals-and-workspace-trust) eines Projekts | MCP | Jede Datei |
| [`enabledPlugins`](#enabledplugins) | Aktiviert oder deaktiviert einzelne [Plugins](https://code.claude.com/docs/de/plugins/overview.md) pro Geltungsbereich | Plugins und Skills | Jede Datei |
| [`enableWorkflows`](#enableworkflows) | Aktiviert oder deaktiviert [dynamische Workflows](https://code.claude.com/docs/de/workflows.md) abweichend vom Standard Ihres Plans | Hooks und Automatisierung | Jede Datei |
| [`enforceAvailableModels`](#enforceavailablemodels) | Hält die [Default-Auswahl in `/model`](https://code.claude.com/docs/de/model-config#enforce-the-allowlist-for-the-default-model) innerhalb Ihrer `availableModels`-Allowlist | Modell und Antworten | Jede Datei |
| [`env`](#env) | Setzt [Umgebungsvariablen](https://code.claude.com/docs/de/env-vars.md#in-settings-files) für jede Sitzung und ihre Unterprozesse | Memory und Kontext | Jede Datei |
| [`externalEditorContext`](#externaleditorcontext) | Zeigt Claudes letzte Antwort als Kommentare an, wenn Sie zum Bearbeiten [Ctrl+G](https://code.claude.com/docs/de/interactive-mode.md#general-controls) drücken | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`extraKnownMarketplaces`](#extraknownmarketplaces) | Registriert [Marketplaces](https://code.claude.com/docs/de/plugins/overview.md) für ein Repository oder eine Organisation | Plugins und Skills | Jede Datei |
| [`fallbackModel`](#fallbackmodel) | Benennt [Ausweichmodelle](https://code.claude.com/docs/de/model-config.md#fallback-model-chains) für den Fall, dass das primäre Modell überlastet ist | Modell und Antworten | Jede Datei |
| [`fastMode`](#fastmode) | Aktiviert den [Fast-Modus](https://code.claude.com/docs/de/fast-mode.md) für Sitzungen, in denen er verfügbar ist | Modell und Antworten | Jede Datei |
| [`fastModePerSessionOptIn`](#fastmodepersessionoptin) | Verlangt, dass der [Fast-Modus](https://code.claude.com/docs/de/fast-mode.md) in jeder Sitzung neu aktiviert wird | Modell und Antworten | Jede Datei |
| [`feedbackDrafts`](#feedbackdrafts) | Legt fest, ob Claude [Feedback-Entwürfe](https://code.claude.com/docs/de/tools-reference.md#sendfeedback-tool-behavior) zur Überprüfung für Sie vormerkt | Datenschutz und Telemetrie | Benutzer oder verwaltet |
| [`feedbackSurveyRate`](#feedbacksurveyrate) | Ändert, wie oft die [Umfrage zur Sitzungsqualität](https://code.claude.com/docs/de/data-usage.md#session-quality-surveys) erscheint | Datenschutz und Telemetrie | Jede Datei |
| [`fileCheckpointingEnabled`](#filecheckpointingenabled) | Deaktiviert oder aktiviert die Datei-Snapshots, die [`/rewind`](https://code.claude.com/docs/de/checkpointing) wiederherstellt | Memory und Kontext | Jede Datei |
| [`fileSuggestion`](#filesuggestion) | Liefert die [`@`-Dateiautovervollständigung](https://code.claude.com/docs/de/interactive-mode#quick-commands) aus Ihrem eigenen Befehl | Oberfläche und Terminal | Jede Datei |
| [`footerLinksRegexes`](#footerlinksregexes) | Macht Issue- oder Review-IDs in der Ausgabe zu [anklickbaren Links](https://code.claude.com/docs/de/statusline.md#clickable-links) unterhalb des Eingabefelds | Oberfläche und Terminal | Benutzer oder verwaltet |
| [`forceLoginGatewayUrl`](#forcelogingatewayurl) | Legt die [Gateway-URL](https://code.claude.com/docs/de/claude-apps-gateway#set-the-gateway-url) fest, mit der sich der Anmeldebildschirm verbindet | Authentifizierung und Anbieter | Benutzer oder verwaltet |
| [`forceLoginMethod`](#forceloginmethod) | [Beschränkt die Anmeldung](https://code.claude.com/docs/de/authentication.md#restrict-login-to-your-organization) auf claude.ai, Claude Console oder ein [Cloud-Gateway](https://code.claude.com/docs/de/claude-apps-gateway) | Authentifizierung und Anbieter | Jede Datei |
| [`forceLoginOrgUUID`](#forceloginorguuid) | [Bindet claude.ai-Anmeldungen an Ihre Organisation](https://code.claude.com/docs/de/authentication.md#restrict-login-to-your-organization); nur eine verwaltete Quelle setzt dies durch | Authentifizierung und Anbieter | Jede Datei |
| [`forceRemoteSettingsRefresh`](#forceremotesettingsrefresh) | Blockiert den Start, bis [serververwaltete Einstellungen](https://code.claude.com/docs/de/server-managed-settings.md) neu abgerufen wurden | Enterprise und verwaltete Einstellungen | Verwaltet |
| [`gatewayInternalNetworks`](#gatewayinternalnetworks) | Lässt `/login` ein [Cloud-Gateway](https://code.claude.com/docs/de/claude-apps-gateway#allow-a-gateway-on-public-address-space-you-own) in öffentlichem IPv4-Adressraum erreichen, den Ihre Organisation intern nutzt | Authentifizierung und Anbieter | Verwaltet |
| [`gcpAuthRefresh`](#gcpauthrefresh) | Aktualisiert [Google Cloud-Anmeldedaten](https://code.claude.com/docs/de/google-vertex-ai.md#advanced-credential-configuration) mit Ihrem eigenen Befehl | Authentifizierung und Anbieter | Jede Datei |
| [`hooks`](#hooks) | Führt Ihre eigenen Befehle als [Hooks](https://code.claude.com/docs/de/hooks.md) an bestimmten Punkten im Lebenszyklus von Claude Code aus | Hooks und Automatisierung | Jede Datei |
| [`httpHookAllowedEnvVars`](#httphookallowedenvvars) | Beschränkt, welche Umgebungsvariablen [HTTP-Hooks](https://code.claude.com/docs/de/hooks.md) in Header einfügen können | Hooks und Automatisierung | Jede Datei |
| [`idleCompaction`](#idlecompaction) | Verhindert, dass Claude Code eine lange Konversation komprimiert, während Sie abwesend sind | Memory und Kontext | Jede Datei |
| [`includeCoAuthoredBy`](#includecoauthoredby) | Veraltet; verwenden Sie `attribution`, um die Attribution in Commits und PRs zu verbergen oder zu ändern | Git und Attribution | Jede Datei |
| [`includeGitInstructions`](#includegitinstructions) | Entfernt die integrierten Commit- und PR-Anweisungen aus Claudes Kontext | Git und Attribution | Jede Datei |
| [`inputNeededNotifEnabled`](#inputneedednotifenabled) | Sendet Ihnen eine [Push-Benachrichtigung](https://code.claude.com/docs/de/remote-control.md#mobile-push-notifications), wenn Claude auf Sie wartet | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`isolatePeerMachines`](#isolatepeermachines) | Fragt Sie, bevor Claude [einer Ihrer Sitzungen auf einem anderen Rechner eine Nachricht sendet](https://code.claude.com/docs/de/cross-session-messaging.md#require-approval-for-cross-machine-messages) | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`keybindingFlavor`](#keybindingflavor) | Veraltet und ohne Wirkung; die Tastenkürzel zur Wortbearbeitung [folgen immer den readline-Konventionen](https://code.claude.com/docs/de/interactive-mode.md#make-ctrl-w-delete-back-to-whitespace) | Oberfläche und Terminal | Jede Datei |
| [`language`](#language) | Lässt Claude in einer anderen Sprache als Englisch antworten | Modell und Antworten | Jede Datei |
| [`leftArrowOpensAgents`](#leftarrowopensagents) | Deaktiviert das Tastenkürzel `←`, das [die Sitzung in den Hintergrund verschiebt und die Agentenansicht öffnet](https://code.claude.com/docs/de/agent-view.md#switch-sessions-without-leaving-the-terminal) | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`managedMcpServers`](#managedmcpservers) | Stellt jedem Benutzer zusätzlich zu den selbst hinzugefügten Servern Remote-[MCP-Server](https://code.claude.com/docs/de/managed-mcp.md#provide-servers-through-managed-settings) bereit | MCP | Verwaltet |
| [`managedSourcesBehavior`](#managedsourcesbehavior) | Kombiniert jede [verwaltete Quelle](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources), die Sie bereitstellen, statt nur die mit der höchsten Priorität zu verwenden | Enterprise und verwaltete Einstellungen | Verwaltet |
| [`maxEffortLevel`](#maxeffortlevel) | Begrenzt die [Effort-Stufe](https://code.claude.com/docs/de/model-config.md#adjust-effort-level) für alle Modelle oder pro Modell, bei jedem Anbieter | Modell und Antworten | Jede Datei |
| [`maxProseWidth`](#maxprosewidth) | Begrenzt, wie breit der Fließtext in Claudes Antworten in einem breiten Terminal läuft | Oberfläche und Terminal | Jede Datei |
| [`minimumVersion`](#minimumversion) | Verhindert, dass [Auto-Updates](https://code.claude.com/docs/de/setup.md#pin-a-minimum-version) eine Version unterhalb einer bestimmten Version installieren | Updates und Versionierung | Jede Datei |
| [`model`](#model) | Ändert das [Modell](https://code.claude.com/docs/de/model-config.md#set-a-default-model-for-new-sessions), mit dem Claude Code startet | Modell und Antworten | Jede Datei |
| [`modelOverrides`](#modeloverrides) | [Ordnet Modell-IDs](https://code.claude.com/docs/de/model-config.md#override-model-ids-per-version) den IDs Ihres Anbieters zu, etwa Bedrock-ARNs | Modell und Antworten | Jede Datei |
| [`modelPicker`](#modelpicker) | Legt fest, welche Modelle die [`/model`-Auswahl](https://code.claude.com/docs/de/model-config#available-models) auflistet, in Ihrer eigenen Reihenfolge und mit Ihren eigenen Bezeichnungen | Modell und Antworten | Benutzer oder verwaltet |
| [`modelPricing`](#modelpricing) | Weist Ausgaben zu den vertraglich vereinbarten Preisen Ihrer Organisation statt zum Listenpreis aus | Modell und Antworten | Verwaltet |
| [`modelSettings`](#modelsettings) | Speichert pro Modell eine [Effort-Stufe](https://code.claude.com/docs/de/model-config.md#adjust-effort-level) oder ein [Fenster für die automatische Komprimierung](https://code.claude.com/docs/de/model-config.md#set-the-auto-compact-window) oder begrenzt den Effort eines Modells | Modell und Antworten | Jede Datei |
| [`otelHeadersHelper`](#otelheadershelper) | Erzeugt rotierende [OpenTelemetry](https://code.claude.com/docs/de/monitoring-usage.md#dynamic-headers)-Header mit Ihrem eigenen Befehl | Authentifizierung und Anbieter | Jede Datei |
| [`outputStyle`](#outputstyle) | Ändert Claudes Rolle, Ton und Ausgabeformat mit einem [Ausgabestil](https://code.claude.com/docs/de/output-styles.md) | Modell und Antworten | Jede Datei |
| [`parentSettingsBehavior`](#parentsettingsbehavior) | Wendet Einschränkungen, die ein [SDK- oder IDE-Host](https://code.claude.com/docs/de/managed-settings.md#let-an-embedding-host-add-policy) übergibt, an oder verwirft sie, wenn Sie [verwaltete Einstellungen](https://code.claude.com/docs/de/managed-settings.md) bereitstellen | Enterprise und verwaltete Einstellungen | Verwaltet |
| [`permissionExplainerEnabled`](#permissionexplainerenabled) | In v2.1.257 entfernt, zusammen mit der `Ctrl+E`-Befehlserklärung in Shell-Berechtigungsabfragen | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`permissions`](#permissions) | Legt allow-, ask- und deny-Regeln sowie den anfänglichen [Berechtigungsmodus](https://code.claude.com/docs/de/permission-modes.md) fest | Berechtigungseinstellungen | Jede Datei |
| [`permissions.additionalDirectories`](#permissions-additionaldirectories) | Gewährt Claude Dateizugriff auf [Verzeichnisse außerhalb des aktuellen](https://code.claude.com/docs/de/permissions.md#working-directories) | Berechtigungseinstellungen | Jede Datei |
| [`permissions.allow`](#permissions-allow) | Genehmigt aufgeführte [Tool-Verwendungen](https://code.claude.com/docs/de/permissions.md#permission-rule-syntax) ohne Nachfrage | Berechtigungseinstellungen | Jede Datei |
| [`permissions.ask`](#permissions-ask) | Fragt vor aufgeführten [Tool-Verwendungen](https://code.claude.com/docs/de/permissions.md#permission-rule-syntax) immer nach | Berechtigungseinstellungen | Jede Datei |
| [`permissions.blockReadsOutsideWorkingDirectories`](#permissions-blockreadsoutsideworkingdirectories) | Lässt die Datei-Tools in jedem Berechtigungsmodus Lesezugriffe außerhalb der [Arbeitsverzeichnisse](https://code.claude.com/docs/de/permissions.md#working-directories) verweigern | Berechtigungseinstellungen | Jede Datei |
| [`permissions.defaultMode`](#permissions-defaultmode) | Legt den [Berechtigungsmodus](https://code.claude.com/docs/de/permission-modes.md#which-mode-a-session-starts-in) fest, in dem neue Sitzungen starten | Berechtigungseinstellungen | Jede Datei |
| [`permissions.deny`](#permissions-deny) | Blockiert aufgeführte [Tool-Verwendungen](https://code.claude.com/docs/de/permissions.md#permission-rule-syntax), einschließlich des Lesens von Dateien mit Geheimnissen | Berechtigungseinstellungen | Jede Datei |
| [`permissions.disableBypassPermissionsMode`](#permissions-disablebypasspermissionsmode) | Verhindert, dass jemand in den [bypassPermissions-Modus](https://code.claude.com/docs/de/permission-modes.md#skip-all-checks-with-bypasspermissions-mode) wechselt | Berechtigungseinstellungen | Jede Datei |
| [`plansDirectory`](#plansdirectory) | Legt fest, wohin der [Plan-Modus](https://code.claude.com/docs/de/permission-modes.md#analyze-before-you-edit-with-plan-mode) Plandateien schreibt | Memory und Kontext | Jede Datei |
| [`pluginConfigs`](#pluginconfigs) | Speichert die Antworten, die Sie im Konfigurationsdialog eines [Plugins](https://code.claude.com/docs/de/plugins/overview.md) gegeben haben | Plugins und Skills | Benutzer oder verwaltet |
| [`pluginSuggestionMarketplaces`](#pluginsuggestionmarketplaces) | Legt fest, welche [Marketplaces](https://code.claude.com/docs/de/plugins/org.md#restrict-what-users-can-install) in `/plugin` Vorschläge zur Plugin-Installation anzeigen können | Plugins und Skills | Verwaltet |
| [`pluginTrustMessage`](#plugintrustmessage) | Fügt der Vertrauenswarnung für [Plugins](https://code.claude.com/docs/de/plugins/overview.md) eigenen Text hinzu | Plugins und Skills | Verwaltet |
| [`policyHelper`](#policyhelper) | Führt beim Start eine ausführbare Datei aus, die [verwaltete Einstellungen](https://code.claude.com/docs/de/managed-settings.md#compute-the-policy-with-a-helper-program) berechnet | Enterprise und verwaltete Einstellungen | Verwaltet |
| [`policyHelper.path`](#policyhelper-path) | Benennt das [ausführbare Hilfsprogramm](https://code.claude.com/docs/de/managed-settings.md#compute-the-policy-with-a-helper-program), das Claude Code ausführt | Enterprise und verwaltete Einstellungen | Verwaltet |
| [`policyHelper.refreshIntervalMs`](#policyhelper-refreshintervalms) | Führt das [Hilfsprogramm](https://code.claude.com/docs/de/managed-settings.md#compute-the-policy-with-a-helper-program) in einem festen Intervall im Hintergrund erneut aus | Enterprise und verwaltete Einstellungen | Verwaltet |
| [`policyHelper.timeoutMs`](#policyhelper-timeoutms) | Legt fest, wie lange Claude Code auf das [Hilfsprogramm](https://code.claude.com/docs/de/managed-settings.md#compute-the-policy-with-a-helper-program) wartet | Enterprise und verwaltete Einstellungen | Verwaltet |
| [`preferredNotifChannel`](#preferrednotifchannel) | Wählt eine [Terminalglocke oder Desktop-Benachrichtigung](https://code.claude.com/docs/de/terminal-config.md#get-a-terminal-bell-or-notification) für den Abschluss von Aufgaben | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`prefersReducedMotion`](#prefersreducedmotion) | [Reduziert oder deaktiviert](https://code.claude.com/docs/de/accessibility.md#accessibility-settings) Spinner-, Schimmer- und Blinkanimationen | Oberfläche und Terminal | Jede Datei |
| [`prependPlugins`](#prependplugins) | Führt die [Mods](https://code.claude.com/docs/de/plugins/mods/admin.md) Ihrer Organisation vor jedem Mod aus, den ein Benutzer installiert | Plugins und Skills | Benutzer oder verwaltet |
| [`processWrapper`](#processwrapper) | Führt die Hintergrundprozesse von Claude Code unter macOS und Linux über einen [Unternehmens-Launcher](https://code.claude.com/docs/de/corporate-launcher.md) aus | Agenten, Sitzungen und Worktrees | Benutzer oder verwaltet |
| [`promptCacheTtl`](#promptcachettl) | Legt die [Lebensdauer des Prompt-Cache](https://code.claude.com/docs/de/prompt-caching.md#cache-lifetime) für die Hauptkonversation fest | Modell und Antworten | Jede Datei |
| [`promptSuggestionEnabled`](#promptsuggestionenabled) | Blendet die ausgegrauten [Prompt-Vorschläge](https://code.claude.com/docs/de/interactive-mode.md#prompt-suggestions) im Eingabefeld aus | Oberfläche und Terminal | Jede Datei |
| [`prStatusFooterEnabled`](#prstatusfooterenabled) | Deaktiviert das Badge für den [PR-Review-Status](https://code.claude.com/docs/de/interactive-mode.md#pr-review-status) in der Fußzeile der Eingabe und die zugrunde liegende Pull-Request-Prüfung | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`prUrlTemplate`](#prurltemplate) | Lässt PR-Links auf ein internes Code-Review-Tool statt auf github.com verweisen | Git und Attribution | Jede Datei |
| [`remote.defaultEnvironmentId`](#remote-defaultenvironmentid) | Wählt die Standard-[Cloud-Umgebung](https://code.claude.com/docs/de/cloud-environments.md) für `claude --cloud`; eine selbst gehostete `ccpool_`-ID wird nur aus Benutzer- und verwalteten Einstellungen sowie aus `--settings` gelesen | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`remoteControlAtStartup`](#remotecontrolatstartup) | Verbindet [Remote Control](https://code.claude.com/docs/de/remote-control.md#enable-remote-control-for-all-sessions) automatisch beim Start einer Sitzung | Remote, Desktop und Benachrichtigungen | Jede Datei |
| [`requiredMaximumVersion`](#requiredmaximumversion) | [Verweigert den Start](https://code.claude.com/docs/de/setup.md#pin-a-minimum-version) mit einer neueren Version, als Ihre Organisation zulässt | Updates und Versionierung | Verwaltet |
| [`requiredMinimumVersion`](#requiredminimumversion) | [Verweigert den Start](https://code.claude.com/docs/de/setup.md#pin-a-minimum-version) mit einer älteren Version, als Ihre Organisation verlangt | Updates und Versionierung | Verwaltet |
| [`respectGitignore`](#respectgitignore) | Hält von Git ignorierte Dateien aus der [`@`-Dateiauswahl](https://code.claude.com/docs/de/interactive-mode#quick-commands) heraus | Oberfläche und Terminal | Jede Datei |
| [`respondToBashCommands`](#respondtobashcommands) | Verhindert, dass Claude nach der Ausführung eines [`!`-Shell-Befehls](https://code.claude.com/docs/de/interactive-mode#shell-mode-with-prefix) antwortet | Oberfläche und Terminal | Jede Datei |
| [`sandbox`](#sandbox) | [Isoliert Bash-Befehle](https://code.claude.com/docs/de/sandboxing.md) unter macOS, Linux und WSL2 von Ihrem Dateisystem und Netzwerk | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.allowAppleEvents`](#sandbox-allowappleevents) | Erlaubt Befehlen, die [in einer Sandbox](https://code.claude.com/docs/de/sandboxing.md) laufen, unter macOS Apple Events zu senden | Sandbox-Einstellungen | Benutzer oder verwaltet |
| [`sandbox.allowNestedUserNamespaces`](#sandbox-allownestedusernamespaces) | Erlaubt Befehlen, die [in einer Sandbox](https://code.claude.com/docs/de/sandboxing.md#chromium-or-rootless-podman-fails-inside-the-sandbox-on-linux) laufen, unter Linux und WSL2 User-Namespaces zu erstellen | Sandbox-Einstellungen | Benutzer oder verwaltet |
| [`sandbox.allowUnsandboxedCommands`](#sandbox-allowunsandboxedcommands) | Erlaubt Claude, einen blockierten Befehl außerhalb der [Sandbox](https://code.claude.com/docs/de/sandboxing.md#the-unsandboxed-retry-escape-hatch) erneut zu versuchen, oder verbietet es | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.autoAllowBashIfSandboxed`](#sandbox-autoallowbashifsandboxed) | Führt Befehle [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md#auto-allow-mode) ohne Berechtigungsabfrage aus | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.bwrapPath`](#sandbox-bwrappath) | Verweist die [Sandbox](https://code.claude.com/docs/de/sandboxing.md) auf eine bubblewrap-Binärdatei außerhalb von `PATH` | Sandbox-Einstellungen | Verwaltet |
| [`sandbox.credentials`](#sandbox-credentials) | Verbirgt oder maskiert Dateien und Variablen mit Anmeldedaten innerhalb der [Sandbox](https://code.claude.com/docs/de/sandboxing.md#protect-credentials) | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.credentials.allowPlaintextInject`](#sandbox-credentials-allowplaintextinject) | Lässt [maskierte Anmeldedaten](https://code.claude.com/docs/de/sandboxing.md#mask-credentials) in vertrauenswürdigen Testnetzwerken einfache HTTP-Dienste erreichen | Sandbox-Einstellungen | Benutzer oder verwaltet |
| [`sandbox.credentials.awsPairs`](#sandbox-credentials-awspairs) | Verknüpft benutzerdefiniert benannte AWS-Schlüsselvariablen zu einem Satz Anmeldedaten für das [erneute Signieren](https://code.claude.com/docs/de/sandboxing.md#re-sign-aws-requests) | Sandbox-Einstellungen | Benutzer oder verwaltet |
| [`sandbox.credentials.envVars`](#sandbox-credentials-envvars) | Entfernt oder maskiert eine Umgebungsvariable innerhalb der [Sandbox](https://code.claude.com/docs/de/sandboxing.md#mask-environment-variables) | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.credentials.files`](#sandbox-credentials-files) | Blockiert oder maskiert Lesezugriffe auf eine Datei mit Anmeldedaten innerhalb der [Sandbox](https://code.claude.com/docs/de/sandboxing.md#mask-credential-files) | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.credentials.sigv4`](#sandbox-credentials-sigv4) | Legt fest, ob Streaming-, vorsignierte oder [SigV4A-AWS-Anfragen](https://code.claude.com/docs/de/sandboxing.md#re-sign-aws-requests) fehlschlagen oder durchgelassen werden | Sandbox-Einstellungen | Benutzer oder verwaltet |
| [`sandbox.enabled`](#sandbox-enabled) | Aktiviert [Bash-Sandboxing](https://code.claude.com/docs/de/sandboxing.md#get-started) unter macOS, Linux und WSL2 | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.enableWeakerNestedSandbox`](#sandbox-enableweakernestedsandbox) | Führt die Linux-[Sandbox](https://code.claude.com/docs/de/sandboxing.md) in einem unprivilegierten Container aus | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.enableWeakerNetworkIsolation`](#sandbox-enableweakernetworkisolation) | Lässt `gh`, `gcloud` und `terraform` unter macOS TLS hinter einem MITM-Proxy innerhalb der [Sandbox](https://code.claude.com/docs/de/sandboxing.md#go-based-clis-fail-tls-verification-on-macos) verifizieren | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.excludedCommands`](#sandbox-excludedcommands) | Benennt Befehle, die Claude Code außerhalb der [Sandbox](https://code.claude.com/docs/de/sandboxing.md) ausführen kann | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.failIfUnavailable`](#sandbox-failifunavailable) | Verweigert den Start, wenn die [Sandbox](https://code.claude.com/docs/de/sandboxing.md) nicht starten kann, statt ohne Sandbox zu laufen | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.filesystem`](#sandbox-filesystem) | Steuert, welche Pfade Befehle [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md#filesystem-isolation) lesen und schreiben können | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.filesystem.allowManagedReadPathsOnly`](#sandbox-filesystem-allowmanagedreadpathsonly) | Verhindert, dass Entwickler [von Ihrer Organisation blockierte Lesepfade](https://code.claude.com/docs/de/sandboxing.md#keep-developers-from-widening-the-policy) wieder öffnen | Sandbox-Einstellungen | Verwaltet |
| [`sandbox.filesystem.allowRead`](#sandbox-filesystem-allowread) | Öffnet den Lesezugriff innerhalb eines Bereichs wieder, den [`denyRead`](#sandbox-filesystem-denyread) blockiert | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.filesystem.allowWrite`](#sandbox-filesystem-allowwrite) | Fügt Pfade hinzu, in die Befehle [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md) schreiben können | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.filesystem.denyRead`](#sandbox-filesystem-denyread) | Verhindert, dass Befehle [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md) bestimmte Pfade lesen | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.filesystem.denyWrite`](#sandbox-filesystem-denywrite) | Verhindert, dass Befehle [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md) in bestimmte Pfade schreiben | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.filesystem.disabled`](#sandbox-filesystem-disabled) | [Deaktiviert die Dateisystemisolierung](https://code.claude.com/docs/de/sandboxing.md#disable-filesystem-isolation), während die Netzwerkisolierung erhalten bleibt | Sandbox-Einstellungen | Benutzer oder verwaltet |
| [`sandbox.ignoreViolations`](#sandbox-ignoreviolations) | Unterdrückt Verstoßberichte für Pfade, die ein Befehl erwartungsgemäß prüft | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network`](#sandbox-network) | Steuert, welche Hosts, Ports und Sockets Befehle [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md#network-isolation) erreichen | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network.allowAllUnixSockets`](#sandbox-network-allowallunixsockets) | Erlaubt Befehlen [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md), sich mit jedem Unix-Socket zu verbinden | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network.allowedDomains`](#sandbox-network-alloweddomains) | Lässt Domains vorab zu, sodass Befehle [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md) nicht dafür nachfragen | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network.allowLocalBinding`](#sandbox-network-allowlocalbinding) | Erlaubt Befehlen [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md), unter macOS auf Netzwerkports zu lauschen und sich mit localhost zu verbinden | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network.allowMachLookup`](#sandbox-network-allowmachlookup) | Lässt Tools [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md) unter macOS, etwa den iOS Simulator oder Playwright, ihre XPC-Dienste erreichen | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network.allowManagedDomainsOnly`](#sandbox-network-allowmanageddomainsonly) | Bindet die Netzwerk-Allowlist an [verwaltete Einstellungen](https://code.claude.com/docs/de/sandboxing.md#keep-developers-from-widening-the-policy) | Sandbox-Einstellungen | Verwaltet |
| [`sandbox.network.allowUnixSockets`](#sandbox-network-allowunixsockets) | Listet Unix-Socket-Pfade auf, die Befehle [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md) unter macOS verwenden können | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network.deniedDomains`](#sandbox-network-denieddomains) | Blockiert Domains für Befehle [in der Sandbox](https://code.claude.com/docs/de/sandboxing.md), auch innerhalb eines zugelassenen Platzhalters | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network.httpProxyPort`](#sandbox-network-httpproxyport) | Leitet HTTP-Verkehr der [Sandbox](https://code.claude.com/docs/de/sandboxing.md#custom-proxy-configuration) über Ihren eigenen Proxy | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network.socksProxyPort`](#sandbox-network-socksproxyport) | Leitet SOCKS-Verkehr der [Sandbox](https://code.claude.com/docs/de/sandboxing.md#custom-proxy-configuration) über Ihren eigenen Proxy | Sandbox-Einstellungen | Jede Datei |
| [`sandbox.network.strictAllowlist`](#sandbox-network-strictallowlist) | Verweigert Hosts außerhalb der [Allowlist](https://code.claude.com/docs/de/sandboxing.md#network-isolation), statt nachzufragen | Sandbox-Einstellungen | Benutzer oder verwaltet |
| [`sandbox.network.tlsTerminate`](#sandbox-network-tlsterminate) | Lässt den Proxy der [Sandbox](https://code.claude.com/docs/de/sandboxing.md#network-isolation) TLS terminieren, damit er HTTPS-Anfragen lesen kann | Sandbox-Einstellungen | Benutzer oder verwaltet |
| [`sandbox.ripgrep`](#sandbox-ripgrep) | Verwendet Ihre eigene ripgrep-Binärdatei innerhalb der [Sandbox](https://code.claude.com/docs/de/sandboxing.md) | Sandbox-Einstellungen | Benutzer oder verwaltet |
| [`sandbox.socatPath`](#sandbox-socatpath) | Verweist den Proxy der [Sandbox](https://code.claude.com/docs/de/sandboxing.md) auf eine `socat`-Binärdatei außerhalb von `PATH` | Sandbox-Einstellungen | Verwaltet |
| [`showClearContextOnPlanAccept`](#showclearcontextonplanaccept) | Zeigt auf dem [Bildschirm zum Annehmen des Plans](https://code.claude.com/docs/de/permission-modes.md#review-and-approve-a-plan) eine Option „clear context“ an | Oberfläche und Terminal | Jede Datei |
| [`showThinkingSummaries`](#showthinkingsummaries) | Zeigt Zusammenfassungen von Claudes [Thinking](https://code.claude.com/docs/de/model-config.md#extended-thinking) statt eines eingeklappten Platzhalters | Modell und Antworten | Jede Datei |
| [`showTurnDuration`](#showturnduration) | Blendet die Dauerangabe „Cooked for“ nach jeder Antwort aus | Oberfläche und Terminal | Jede Datei |
| [`skillListingBudgetFraction`](#skilllistingbudgetfraction) | Reserviert mehr oder weniger Kontext für die [Skill-Liste](https://code.claude.com/docs/de/skills.md#skill-descriptions-are-cut-short) | Memory und Kontext | Jede Datei |
| [`skillListingMaxDescChars`](#skilllistingmaxdescchars) | Begrenzt die Beschreibungslänge jedes Skills in der [Skill-Liste](https://code.claude.com/docs/de/skills.md#skill-descriptions-are-cut-short) | Memory und Kontext | Jede Datei |
| [`skillOverrides`](#skilloverrides) | [Blendet einen Skill aus oder klappt ihn ein](https://code.claude.com/docs/de/skills.md#override-skill-visibility-from-settings), ohne seine SKILL.md zu bearbeiten | Plugins und Skills | Jede Datei |
| [`skipAutoPermissionPrompt`](#skipautopermissionprompt) | Überspringt den einmaligen Hinweis, den Claude Code anzeigt, wenn Sie den [Auto-Modus](https://code.claude.com/docs/de/permission-modes.md#eliminate-prompts-with-auto-mode) zum ersten Mal selbst aktivieren statt über den integrierten Standard | Berechtigungseinstellungen | Benutzer oder verwaltet |
| [`skipDangerousModePermissionPrompt`](#skipdangerousmodepermissionprompt) | Überspringt den Bestätigungsdialog vor dem [bypassPermissions-Modus](https://code.claude.com/docs/de/permission-modes.md#skip-all-checks-with-bypasspermissions-mode) | Berechtigungseinstellungen | Benutzer, lokal oder verwaltet |
| [`skipWebFetchPreflight`](#skipwebfetchpreflight) | Überspringt die [WebFetch-Hostnamenprüfung](https://code.claude.com/docs/de/tools-reference.md#webfetch-tool-behavior), wenn Anthropic nicht erreichbar ist | Datenschutz und Telemetrie | Jede Datei |
| [`spellcheck`](#spellcheck) | Unterstreicht falsch geschriebene Wörter in der Prompt-Eingabe mit einer von Ihnen installierten [Rechtschreibprüfung](https://code.claude.com/docs/de/interactive-mode.md#check-spelling-as-you-type) | Oberfläche und Terminal | Benutzer oder verwaltet |
| [`spinnerTipsEnabled`](#spinnertipsenabled) | Blendet Tipps im Spinner aus, während Claude arbeitet | Oberfläche und Terminal | Jede Datei |
| [`spinnerTipsOverride`](#spinnertipsoverride) | Fügt der Spinner-Rotation eigene Tipps hinzu oder ersetzt die integrierten Tipps | Oberfläche und Terminal | Jede Datei |
| [`spinnerVerbs`](#spinnerverbs) | Ergänzt oder ersetzt die Verben, die während eines Turns angezeigt werden | Oberfläche und Terminal | Jede Datei |
| [`sshConfigs`](#sshconfigs) | Fügt der Umgebungsauswahl von Desktop [SSH-Verbindungen](https://code.claude.com/docs/de/desktop.md#pre-configure-ssh-connections-for-your-team) hinzu | Remote, Desktop und Benachrichtigungen | Benutzer oder verwaltet |
| [`sshHostAllowlist`](#sshhostallowlist) | Beschränkt, welche Hosts [Desktop-SSH-Sitzungen](https://code.claude.com/docs/de/desktop.md#restrict-which-ssh-hosts-users-can-connect-to) erreichen können | Remote, Desktop und Benachrichtigungen | Verwaltet |
| [`sshHostCommands`](#sshhostcommands) | Fügt der Umgebungsauswahl von Desktop [SSH-Verbindungen hinzu, deren Host aus einem Befehl stammt](https://code.claude.com/docs/de/desktop.md#create-an-ssh-connection-from-a-command) | Remote, Desktop und Benachrichtigungen | Benutzer oder verwaltet |
| [`statusLine`](#statusline) | Führt Ihren eigenen Befehl aus, um unterhalb der Eingabe eine [Statuszeile](https://code.claude.com/docs/de/statusline.md) darzustellen | Oberfläche und Terminal | Jede Datei |
| [`strictKnownMarketplaces`](#strictknownmarketplaces) | Legt per Allowlist die [Marketplace](https://code.claude.com/docs/de/plugins/overview.md)-Quellen fest, die Benutzer hinzufügen und aus denen sie installieren können | Plugins und Skills | Verwaltet |
| [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) | Blockiert [Skills](https://code.claude.com/docs/de/skills.md), [Agenten](https://code.claude.com/docs/de/sub-agents.md), [Hooks](https://code.claude.com/docs/de/hooks.md) und [MCP-Server](https://code.claude.com/docs/de/mcp.md) aus Benutzer- und Projektquellen | Plugins und Skills | Verwaltet |
| [`strictPluginOnlyCustomization.agents`](#strictpluginonlycustomization-agents) | Beschränkt [Agenten](https://code.claude.com/docs/de/sub-agents.md) auf Plugin- und verwaltete Quellen | Plugins und Skills | Verwaltet |
| [`strictPluginOnlyCustomization.hooks`](#strictpluginonlycustomization-hooks) | Beschränkt [Hooks](https://code.claude.com/docs/de/hooks.md) auf Plugin- und verwaltete Quellen | Plugins und Skills | Verwaltet |
| [`strictPluginOnlyCustomization.mcp`](#strictpluginonlycustomization-mcp) | Beschränkt [MCP-Server](https://code.claude.com/docs/de/mcp.md) auf Plugin- und verwaltete Quellen | Plugins und Skills | Verwaltet |
| [`strictPluginOnlyCustomization.skills`](#strictpluginonlycustomization-skills) | Beschränkt [Skills](https://code.claude.com/docs/de/skills.md) auf Plugin- und verwaltete Quellen | Plugins und Skills | Verwaltet |
| [`subagentPromptCacheTtl`](#subagentpromptcachettl) | Legt die [Lebensdauer des Prompt-Cache](https://code.claude.com/docs/de/prompt-caching.md#cache-lifetime) für Subagenten und andere Anfragen außerhalb der Hauptkonversation fest | Modell und Antworten | Jede Datei |
| [`subagentStatusLine`](#subagentstatusline) | Schreibt Zeilen in der Aufgabenanzeige von [Subagenten](https://code.claude.com/docs/de/sub-agents.md) mit Ihrem eigenen Befehl um | Oberfläche und Terminal | Jede Datei |
| [`switchModelsOnFlag`](#switchmodelsonflag) | Wechselt automatisch das Modell oder pausiert, wenn ein [Sicherheitsklassifikator](https://code.claude.com/docs/de/model-config.md#ask-before-switching) eine Anfrage kennzeichnet | Modell und Antworten | Jede Datei |
| [`syncClaudeAiPlugins`](#syncclaudeaiplugins) | Beendet das Laden der [in Ihrem claude.ai-Konto aktivierten Plugins](https://code.claude.com/docs/de/plugins/loading.md#synced-plugins) und das Herunterladen neuer Plugins | Plugins und Skills | Benutzer, lokal oder verwaltet |
| [`syncClaudeAiSkills`](#syncclaudeaiskills) | Beendet das Laden der [in Ihrem claude.ai-Konto aktivierten Skills](https://code.claude.com/docs/de/skills.md#how-synced-skills-behave) und das Herunterladen neuer Skills | Plugins und Skills | Benutzer, lokal oder verwaltet |
| [`syntaxHighlightingDisabled`](#syntaxhighlightingdisabled) | Deaktiviert die Syntaxhervorhebung in Diffs und Codeblöcken | Oberfläche und Terminal | Jede Datei |
| [`taskOutputMaxChars`](#taskoutputmaxchars) | In v2.1.277 entfernt, zusammen mit dem Tool `TaskOutput`, dessen Größe es festlegte | Memory und Kontext | Jede Datei |
| [`teammateDefaultModel`](#teammatedefaultmodel) | In v2.1.234 entfernt; unter [Teammates und Modelle festlegen](https://code.claude.com/docs/de/agent-teams.md#specify-teammates-and-models) erfahren Sie, wie Claude Code das Modell eines Teammates auswählt | Einstellungen der globalen Konfiguration | Globale Konfiguration |
| [`teammateMode`](#teammatemode) | Legt fest, wie [Teammates eines Agent-Teams angezeigt werden](https://code.claude.com/docs/de/agent-teams.md#choose-a-display-mode) | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`terminalProgressBarEnabled`](#terminalprogressbarenabled) | Blendet die Terminal-Fortschrittsanzeige in Terminals aus, die sie unterstützen | Oberfläche und Terminal | Jede Datei |
| [`terminalTitleFromRename`](#terminaltitlefromrename) | Verhindert, dass [`/rename`](https://code.claude.com/docs/de/sessions#name-your-sessions) und `--name` den Titel des Terminal-Tabs ändern | Oberfläche und Terminal | Jede Datei |
| [`theme`](#theme) | Wählt das [Farbschema](https://code.claude.com/docs/de/terminal-config.md#match-the-color-theme) der Oberfläche, integriert oder benutzerdefiniert | Oberfläche und Terminal | Jede Datei |
| [`timeFormat`](#timeformat) | Zeigt Uhrzeiten in der Oberfläche im 12- oder 24-Stunden-Format, in UTC oder mit einem strftime-Muster an | Oberfläche und Terminal | Jede Datei |
| [`timeZone`](#timezone) | Zeigt Uhrzeiten in der Oberfläche in einer anderen Zeitzone als der Ihres Systems an | Oberfläche und Terminal | Jede Datei |
| [`tui`](#tui) | Wählt den [Vollbild](https://code.claude.com/docs/de/fullscreen.md)- oder den klassischen Terminal-Renderer | Oberfläche und Terminal | Jede Datei |
| [`ultracode`](#ultracode) | Lässt Claude für jede substanzielle Aufgabe unaufgefordert einen [Workflow](https://code.claude.com/docs/de/workflows.md#let-claude-decide-with-ultracode) planen | Modell und Antworten | Jede Datei |
| [`useAutoModeDuringPlan`](#useautomodeduringplan) | Lässt den Klassifikator des [Auto-Modus](https://code.claude.com/docs/de/permission-modes.md#eliminate-prompts-with-auto-mode) Shell-Befehle im [Plan-Modus](https://code.claude.com/docs/de/permission-modes.md#analyze-before-you-edit-with-plan-mode) prüfen; setzen Sie `false`, um stattdessen Berechtigungsabfragen zu erhalten | Berechtigungseinstellungen | Benutzer, lokal oder verwaltet |
| [`verbose`](#verbose) | Zeigt die [vollständige Tool-Ausgabe](https://code.claude.com/docs/de/cli-reference.md#cli-flags) statt gekürzter Zusammenfassungen; `viewMode` hat Vorrang, wenn beide gesetzt sind | Oberfläche und Terminal | Jede Datei |
| [`viewMode`](#viewmode) | Startet jede Sitzung in der [Standard-, ausführlichen oder Fokusansicht](https://code.claude.com/docs/de/cli-reference.md#cli-flags) | Oberfläche und Terminal | Jede Datei |
| [`vimInsertModeRemaps`](#viminsertmoderemaps) | Belegt eine Zwei-Tasten-[Sequenz im INSERT-Modus](https://code.claude.com/docs/de/interactive-mode.md#remap-insert-mode-key-sequences) wie `jj` mit Escape | Oberfläche und Terminal | Benutzer oder verwaltet |
| [`voice`](#voice) | Aktiviert das [Sprachdiktat](https://code.claude.com/docs/de/voice-dictation.md) und wählt den Halte- oder Tippmodus | Oberfläche und Terminal | Jede Datei |
| [`voiceEnabled`](#voiceenabled) | Aktiviert das [Sprachdiktat](https://code.claude.com/docs/de/voice-dictation.md) mit der älteren Form mit einem einzelnen Schlüssel | Oberfläche und Terminal | Jede Datei |
| [`wheelScrollAccelerationEnabled`](#wheelscrollaccelerationenabled) | Deaktiviert die [Mausrad-Beschleunigung](https://code.claude.com/docs/de/fullscreen.md#mouse-wheel-scrolling) im Vollbild-Rendering | Oberfläche und Terminal | Jede Datei |
| [`workflowKeywordTriggerEnabled`](#workflowkeywordtriggerenabled) | Lässt das Wort `ultracode` in einem Prompt einen [Workflow](https://code.claude.com/docs/de/workflows.md) starten; setzen Sie `false`, um es einzugeben, ohne einen Workflow zu starten | Hooks und Automatisierung | Jede Datei |
| [`workflowSizeGuideline`](#workflowsizeguideline) | Legt die Anzahl der Agenten fest, die Claude in [dynamischen Workflows](https://code.claude.com/docs/de/workflows.md) anstrebt | Hooks und Automatisierung | Jede Datei |
| [`worktree`](#worktree) | Konfiguriert, wie Claude Code Git-[Worktrees](https://code.claude.com/docs/de/worktrees.md) erstellt | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`worktree.baseRef`](#worktree-baseref) | Erstellt neue [Worktrees](https://code.claude.com/docs/de/worktrees.md) vom Remote-Standard-Branch oder von Ihrem lokalen HEAD | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`worktree.bgIsolation`](#worktree-bgisolation) | Lässt Hintergrundsitzungen die Arbeitskopie ohne [Worktree](https://code.claude.com/docs/de/worktrees.md) bearbeiten | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`worktree.location`](#worktree-location) | Legt fest, wo [Desktop-SSH-Sitzungen](https://code.claude.com/docs/de/desktop.md#ssh-sessions) ihre Worktrees auf einem Remote-Rechner erstellen | Agenten, Sitzungen und Worktrees | Benutzer |
| [`worktree.sparsePaths`](#worktree-sparsepaths) | Checkt in jedem [Worktree](https://code.claude.com/docs/de/worktrees.md) nur die benötigten Verzeichnisse aus | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`worktree.symlinkDirectories`](#worktree-symlinkdirectories) | Verknüpft große Verzeichnisse per Symlink in jeden [Worktree](https://code.claude.com/docs/de/worktrees.md), statt sie zu duplizieren | Agenten, Sitzungen und Worktrees | Jede Datei |
| [`wslInheritsWindowsSettings`](#wslinheritswindowssettings) | Lässt WSL [verwaltete Einstellungen](https://code.claude.com/docs/de/managed-settings.md) aus der Windows-Richtlinienkette lesen | Enterprise und verwaltete Einstellungen | Verwaltet |

## Modell und Antworten

Wählen Sie, welche Modelle Claude Code verwendet und wie es antwortet. Informationen darüber, wie diese Einstellungen mit dem Befehl `/model` und Umgebungsvariablen interagieren, finden Sie unter [Modellkonfiguration](https://code.claude.com/docs/de/model-config.md).

### `advisorModel`

Wählen Sie, welches Modell antwortet, wenn Claude das serverseitige [Advisor-Tool](https://code.claude.com/docs/de/advisor.md) aufruft. Entfernen Sie den Wert, um den Advisor auszuschalten. Der Advisor muss mindestens so leistungsfähig sein wie Ihr Hauptmodell. Informationen zu akzeptierten Kombinationen und was passiert, wenn Sie eine nicht akzeptierte Kombination wählen, finden Sie unter [Wählen Sie ein Advisor-Modell](https://code.claude.com/docs/de/advisor.md#choose-an-advisor-model).

Sie bearbeiten diesen Schlüssel normalerweise nicht manuell. Führen Sie `/advisor` aus, um eine Auswahl zu öffnen, die die aktuelle Auswahl, die Modelle, die beraten können, und **Kein Advisor** anzeigt. Claude Code speichert Ihre Auswahl in diesem Schlüssel in `~/.claude/settings.json`. Wenn Sie aus einem [Remote Control](https://code.claude.com/docs/de/remote-control.md)-Client oder in einer Sitzung auswählen, die an einen Remote Worker angehängt ist, gilt die Auswahl nur für diese Sitzung und ändert diesen Schlüssel nicht.

Wenn Ihr Konto die [Zustimmung zu Nutzungsguthaben](https://code.claude.com/docs/de/advisor.md#fable-advisor-and-usage-credits) erfordert, akzeptieren Sie diese zuerst, indem Sie `/model fable` ausführen. Bis dahin speichert die Auswahl von Fable in `/advisor` nichts und Claude Code teilt Ihnen mit, dass Sie zuerst `/model fable` ausführen sollen.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: String, einer der Aliase `"fable"`, `"opus"` oder `"sonnet"`, die in die aktuelle Standardversion dieser Modellfamilie von Claude Code aufgelöst werden, oder eine vollständige Modell-ID wie `"claude-opus-5-5"`
* **Standard**: nicht gesetzt, daher ist der Advisor ausgeschaltet
* **Überschreibungen pro Sitzung**: `--advisor` hat für eine Sitzung Vorrang vor diesem Schlüssel. [`CLAUDE_CODE_DISABLE_ADVISOR_TOOL`](https://code.claude.com/docs/de/env-vars) schaltet den Advisor aus, und dieser Schlüssel kann ihn nicht wieder einschalten

```json settings.json theme={null}
{
  "advisorModel": "opus"
}
```

Der Schlüssel hat keine Auswirkung auf Provider, bei denen der Advisor [nicht verfügbar](https://code.claude.com/docs/de/advisor.md#requirements) ist, wie Amazon Bedrock und Claude Platform auf AWS. `"fable"` erfordert [Fable-Zugriff](https://code.claude.com/docs/de/advisor.md#choose-an-advisor-model).

### `alwaysThinkingEnabled`

Deaktivieren Sie [Extended Thinking](https://code.claude.com/docs/de/model-config.md#extended-thinking) für jede Sitzung, indem Sie dies auf `false` setzen. Thinking ist standardmäßig aktiviert, daher ändert `true` nichts. Die meisten Benutzer stellen dies über `/config` ein, anstatt die Datei zu bearbeiten.

Bei Modellen, die immer nachdenken, wie Opus 5.5, Sonnet 5.5, Haiku 5.5 und die Fable-Modelle, hat `false` keine Auswirkung. Bei [Drittanbieter-Providern](https://code.claude.com/docs/de/third-party-integrations.md) lässt Claude Code den Parameter `thinking` weg, anstatt Thinking auszuschalten, daher können Modelle mit adaptivem Reasoning möglicherweise trotzdem nachdenken. Wenn Thinking auf der Anthropic API ausgeschaltet ist, sendet Claude Code den Effort `high` statt einer höheren Stufe an Modelle, von denen es weiß, dass sie [diese Kombination nicht akzeptieren](https://code.claude.com/docs/de/errors.md#effort-isnt-available-with-thinking-turned-off), wie Opus 5.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: Boolean
  * `true`: keine Auswirkung; Thinking ist bereits aktiviert
  * `false`: Claude Code deaktiviert Extended Thinking für jede Sitzung
* **Standard**: nicht gesetzt, daher ist Thinking für Modelle aktiviert, die es unterstützen
* **Überschreibungen pro Sitzung**: [`MAX_THINKING_TOKENS`](https://code.claude.com/docs/de/env-vars) hat für eine Sitzung Vorrang vor diesem Schlüssel: `0` deaktiviert Thinking unter den gleichen Modell- und Provider-Einschränkungen wie `false`, und ein positiver Wert aktiviert Thinking, auch wenn dieser Schlüssel `false` ist. Bei Modellen mit adaptivem Reasoning wird die Zahl selbst ignoriert

```json settings.json theme={null}
{
  "alwaysThinkingEnabled": false
}
```

### `availableModels`

Beschränken Sie, welche Modelle Personen für die Hauptsitzung, [Subagenten](https://code.claude.com/docs/de/sub-agents.md), [Skills](https://code.claude.com/docs/de/skills.md) und den [Advisor](https://code.claude.com/docs/de/advisor.md) auswählen können. Eine verwaltete Liste beschränkt `/model`, `--model` und den Schlüssel `model` in den eigenen Dateien eines Entwicklers; ein Modell außerhalb davon kann nicht ausgewählt werden. Mit dem standardmäßigen Präfixabgleich berührt dies die Option Standard allein nicht; kombinieren Sie es dafür mit [`enforceAvailableModels`](#enforceavailablemodels).

* **Geltungsbereich**: [`Beliebige Datei`](#scopes). Stellen Sie es in verwalteten Einstellungen bereit, um es für eine Organisation durchzusetzen.
* **Typ**: Array von Modellaliasen oder IDs
* **Standard**: nicht gesetzt, daher sind alle Modelle verfügbar

Dieses Beispiel ermöglicht es Personen, nur Sonnet- und Haiku-Modelle auszuwählen:

```json settings.json theme={null}
{
  "availableModels": ["sonnet", "haiku"]
}
```

Ein Modell-ID-Eintrag wie `"claude-opus-5"` erlaubt auch spätere Versionen, die ihn erweitern, wie Opus 5.5. Um eine dieser Versionen zu blockieren, verwenden Sie [`deniedModels`](#deniedmodels). Damit jeder Modell-ID-Eintrag nur die genannte Version erlaubt, verwenden Sie [`availableModelsMatch`](#availablemodelsmatch). Siehe [Modellauswahl einschränken](https://code.claude.com/docs/de/model-config.md#restrict-model-selection). Informationen zu Provider-IDs von Drittanbietern finden Sie unter [Modelle für Drittanbieter-Bereitstellungen festlegen](https://code.claude.com/docs/de/model-config.md#pin-models-for-third-party-deployments).

### `availableModelsMatch`

Legen Sie fest, wie Einträge in [`availableModels`](#availablemodels) mit Modell-IDs abgeglichen werden. Standardmäßig erlaubt ein Modell-ID-Eintrag auch spätere Versionen, die ihn erweitern, sodass `"claude-opus-5"` Opus 5.5 erlaubt. Mit `"exact"` erlaubt jeder Modell-ID-Eintrag nur die genannte Version, sodass eine neuere Version dieses Modells blockiert bleibt, bis Sie sie auflisten. Erfordert Claude Code v2.1.283 oder später.

* **Geltungsbereich**: [`Verwaltet`](#scopes). Claude Code ignoriert den Schlüssel in Benutzer-, Projekt- und lokalen Einstellungen sowie in `--settings` mit einer Warnung
* **Typ**: String, einer von:
  * `"prefix"`: ein Modell-ID-Eintrag erlaubt seine Version und jede Modell-ID, die ihn um ein weiteres Segment erweitert
  * `"exact"`: ein Modell-ID-Eintrag erlaubt nur die genannte Version, sodass `"claude-opus-5"` Opus 5 erlaubt, aber nicht `claude-opus-5-5`. Ein Eintrag wie `"claude-opus-4-5"` erlaubt auch seine datierte Anthropic-Modell-ID `claude-opus-4-5-20251101`. Ein Familienalias wie `"opus"` erlaubt weiterhin die gesamte Familie, und Einträge `best`, `opusplan` und `default` werden ignoriert
* **Standard**: `"prefix"`

Dieses Beispiel erlaubt Opus 5 und Sonnet 5, aber keine spätere Version eines der beiden:

```json managed-settings.json theme={null}
{
  "availableModels": ["claude-opus-5", "claude-sonnet-5"],
  "availableModelsMatch": "exact"
}
```

Mit `"exact"` ist auch die Option Standard auf die aufgelisteten Modelle beschränkt, sobald die Liste mindestens ein Modell oder eine Familie nennt. Siehe [Bestimmte Modelle oder Versionen blockieren](https://code.claude.com/docs/de/model-config.md#block-specific-models-or-versions).

### `deniedModels`

Blockieren Sie bestimmte Modelle, mit oder ohne [`availableModels`](#availablemodels)-Allowlist und selbst dann, wenn diese Liste sie erlaubt. Claude Code blendet ein blockiertes Modell in der Auswahl `/model` aus, und das Modell kann nirgends ausgewählt werden, wo `availableModels` durchgesetzt wird. Eine Sitzung mit der Option Standard führt ein blockiertes Modell ebenfalls nicht aus, wie unter [Bestimmte Modelle oder Versionen blockieren](https://code.claude.com/docs/de/model-config.md#block-specific-models-or-versions) beschrieben. Erfordert Claude Code v2.1.283 oder später.

* **Geltungsbereich**: [`Verwaltet`](#scopes). Claude Code ignoriert den Schlüssel in Benutzer-, Projekt- und lokalen Einstellungen sowie in `--settings` mit einer Warnung
* **Typ**: Array von Modellaliasen oder IDs
  * Ein Familienalias wie `"opus"` blockiert jedes Modell dieser Familie
  * Eine Modell-ID wie `"claude-opus-5-5"` blockiert diese Version in jeder Schreibweise, einschließlich datierter und providerspezifischer IDs
  * Eine Modell-ID ohne Nebenversion, wie `"claude-opus-5"`, blockiert auch spätere Nebenversionen wie Opus 5.5. Schreiben Sie `"claude-opus-5-0"`, um nur Opus 5 zu blockieren
  * Einträge `best`, `opusplan` und `default` werden ignoriert
* **Standard**: nicht gesetzt, daher ist kein Modell blockiert

Dieses Beispiel erlaubt Opus- und Sonnet-Modelle und blockiert Opus 5.5:

```json managed-settings.json theme={null}
{
  "availableModels": ["opus", "sonnet"],
  "deniedModels": ["claude-opus-5-5"]
}
```

Siehe [Bestimmte Modelle oder Versionen blockieren](https://code.claude.com/docs/de/model-config.md#block-specific-models-or-versions).

### `effortLevel`

Legen Sie eine Standard-[Effort-Stufe](https://code.claude.com/docs/de/model-config.md#adjust-effort-level) für Modelle fest, für die Sie noch keine Stufe gespeichert haben. Niedrigere Stufen sind bei einfachen Aufgaben schneller und günstiger, höhere Stufen denken bei komplexen Problemen gründlicher nach.

Wenn Sie `/effort low`, `medium`, `high` oder `xhigh` in einer interaktiven Sitzung auf Ihrem Computer ausführen, speichert Claude Code die Stufe für das aktive Modell unter [`modelSettings`](#modelsettings), anstatt diesen Schlüssel zu schreiben. Vor v2.1.251 schrieb `/effort` diesen Schlüssel.

Innerhalb derselben Einstellungsdatei verwendet Claude Code die gespeicherte Stufe eines Modells anstelle dieses Schlüssels. [`modelSettings`](#modelsettings) beschreibt die dateiübergreifende Rangfolge.

In einer Sitzung, die an einen Remote Worker angehängt ist, in einem `-p`-Lauf und im Agent SDK gilt `/effort` nur für diese Sitzung. [Effort-Stufe anpassen](https://code.claude.com/docs/de/model-config.md#adjust-effort-level) listet die interaktiven Auswahlmöglichkeiten auf, die ebenfalls nur für diese Sitzung gelten. Die Meldung, die `/effort` ausgibt, sagt, was passiert ist.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: String, einer von:
  * `"low"`: das geringste Reasoning, für kurze, klar umrissene, latenzempfindliche Aufgaben, die keine hohe Intelligenz erfordern
  * `"medium"`: reduziert die Token-Nutzung für kostensensitive Arbeiten, die etwas Intelligenz opfern können
  * `"high"`: balanciert Token-Nutzung und Intelligenz
  * `"xhigh"`: tieferes Reasoning bei höherem Token-Verbrauch
* **Standard**: nicht gesetzt
* **Überschreibungen pro Sitzung**: `--effort` hat für eine Sitzung Vorrang vor diesem Schlüssel, und [`CLAUDE_CODE_EFFORT_LEVEL`](https://code.claude.com/docs/de/env-vars) hat Vorrang vor beiden

```json settings.json theme={null}
{
  "effortLevel": "xhigh"
}
```

In Ihrer Benutzereinstellungsdatei `~/.claude/settings.json` ist dieser Schlüssel die ältere Form, die `/effort` schrieb, bevor Stufen pro Modell gespeichert wurden, und er gilt weiterhin dort, wo er zuvor galt: für Opus 5, Fable 5.1 und frühere Modelle. Opus 5.5 und später veröffentlichte Modelle ignorieren ihn und beginnen mit ihrem eigenen Standard, bis Sie eine Stufe für sie speichern, die `/effort` unter [`modelSettings`](#modelsettings) schreibt. In Projekt-, lokalen und verwalteten Einstellungen sowie mit `--settings` gilt dieser Schlüssel für jedes Modell.

### `enforceAvailableModels`

Die Auswahl `/model` hat eine Option **Standard**, und unter [Einstellung des Modells `default`](https://code.claude.com/docs/de/model-config#default-model-setting) ist beschrieben, zu welchem Modell sie aufgelöst wird. Eine [`availableModels`](#availablemodels)-Allowlist beschränkt die Modelle, die Sie benennen können, aber mit dem standardmäßigen [Präfixabgleich](#availablemodelsmatch) ordnet sie den Standard Ihres Kontotyps nicht neu zu, sodass **Standard** immer noch zu einem Modell außerhalb der Liste aufgelöst werden kann. Dieser Schlüssel schließt diese Lücke. Erfordert Claude Code v2.1.175 oder später.

Wenn Ihre Organisation verwaltete Einstellungen bereitstellt, liest Claude Code diesen Schlüssel nur aus der verwalteten Quelle und ignoriert ihn in Ihren anderen Dateien.

Wie dieser Schlüssel bei den Modellprüfungen beim Start angewendet wird, erfahren Sie unter [Amazon Bedrock](https://code.claude.com/docs/de/amazon-bedrock.md#when-your-organization-enforces-a-model-allowlist) und [Google Cloud's Agent Platform](https://code.claude.com/docs/de/google-vertex-ai.md#when-your-organization-enforces-a-model-allowlist).

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: Boolean
  * `true`: wenn **Standard** zu einem Modell außerhalb von `availableModels` aufgelöst würde, löst Claude Code es stattdessen zum ersten verfügbaren Modell in der Liste auf
  * `false`: dieser Schlüssel ändert nicht, wie **Standard** aufgelöst wird
* **Standard**: `false`

Dieses Beispiel beschränkt benannte Auswahlmöglichkeiten auf Sonnet- und Haiku-Modelle und lässt **Standard** zum ersten verfügbaren dieser Modelle auflösen:

```json settings.json theme={null}
{
  "availableModels": ["sonnet", "haiku"],
  "enforceAvailableModels": true
}
```

Dieser Schlüssel hat keine Auswirkung, wenn `availableModels` nicht gesetzt oder leer ist. Siehe [Allowlist für das Standardmodell durchsetzen](https://code.claude.com/docs/de/model-config.md#enforce-the-allowlist-for-the-default-model). Erfordert Claude Code v2.1.175 oder später.

### `fallbackModel`

Benennen Sie Backup-Modelle, die Claude Code der Reihe nach versuchen soll, wenn Ihr primäres Modell überlastet oder nicht verfügbar ist. Claude Code wechselt für den Rest des Turns zum nächsten verfügbaren Modell in der Kette und zeigt einen Hinweis an. Ohne eine Kette versucht Claude Code dasselbe Modell erneut und zeigt dann den Fehler des Servers an, und Sie versuchen es selbst erneut oder wechseln das Modell.

Ein Wechsel bedeutet einen Turn mit einem kalten [Prompt-Cache](https://code.claude.com/docs/de/prompt-caching.md#switching-models) auf dem Fallback-Modell; Ihre nächste Nachricht versucht zuerst wieder das primäre Modell.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: Array von Modellaliasen oder IDs; `"default"` wird zum Standardmodell erweitert
* **Standard**: nicht gesetzt, daher wird eine fehlgeschlagene Anfrage nicht mit einem anderen Modell erneut versucht
* **Überschreibungen pro Sitzung**: `--fallback-model` hat für eine Sitzung Vorrang vor diesem Schlüssel

Dieses Beispiel versucht zuerst Sonnet 5, dann Haiku 4.5, wenn Ihr primäres Modell fehlschlägt:

```json settings.json theme={null}
{
  "fallbackModel": ["claude-sonnet-5", "claude-haiku-4-5"]
}
```

Im Gegensatz zu den meisten Array-Einstellungen wird dieser Schlüssel nicht über Einstellungsdateien hinweg zusammengeführt: Die Datei mit dem höchsten Vorrang, die ihn definiert, liefert die ganze Kette. Wenn Ihre Projektdatei `["claude-sonnet-5"]` setzt und Ihre Benutzerdatei `["claude-haiku-4-5"]` setzt, ist die Kette nur `["claude-sonnet-5"]`. Claude Code behält höchstens drei unterschiedliche zulässige Modelle aus der Liste und ignoriert den Rest. Siehe [Fallback-Modellketten](https://code.claude.com/docs/de/model-config.md#fallback-model-chains).

### `fastMode`

Aktivieren Sie den [Fast-Modus](https://code.claude.com/docs/de/fast-mode.md) für Sitzungen, in denen er verfügbar ist, für interaktive Arbeiten wie schnelle Iteration oder Live-Debugging, bei denen Sie Geschwindigkeit zu höheren Kosten pro Token wünschen. Sie bearbeiten diesen Schlüssel normalerweise nicht manuell: Das Ausführen von `/fast` schreibt `fastMode: true` in `~/.claude/settings.json`, und das erneute Ausführen zum Ausschalten des Fast-Modus entfernt den Schlüssel. Der Fast-Modus läuft nur auf Opus 5.5, Opus 5 und Opus 4.8: Wenn Sie ihn von einem anderen Modell aus aktivieren, wechseln Sie zu Opus, und der Wechsel zu einem nicht unterstützten Modell schaltet ihn aus. Siehe [Modelle wechseln, während der Fast-Modus aktiv ist](https://code.claude.com/docs/de/fast-mode.md#switch-models-while-fast-mode-is-on).

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code aktiviert den Fast-Modus für Sitzungen, in denen er verfügbar ist
  * `false`: Der Fast-Modus bleibt ausgeschaltet
* **Standard**: nicht gesetzt, daher ist der Fast-Modus ausgeschaltet
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_DISABLE_FAST_MODE`](https://code.claude.com/docs/de/env-vars) schaltet den Fast-Modus für eine Sitzung aus, und dieser Schlüssel kann ihn nicht wieder einschalten

```json settings.json theme={null}
{
  "fastMode": true
}
```

### `fastModePerSessionOptIn`

Normalerweise speichert das Ausführen von `/fast` [`fastMode`](#fastmode) in den Benutzereinstellungen einer Person, sodass der Fast-Modus zu Beginn jeder späteren Sitzung aktiviert ist. Setzen Sie diesen Schlüssel auf `true`, um das zu verhindern: Ein gespeichertes `fastMode: true` aktiviert den Fast-Modus nicht mehr beim Sitzungsstart, und jede Person muss `/fast` in jeder Sitzung ausführen, in der sie ihn möchte. Claude Code lässt den Schlüssel `fastMode` in ihrer Datei, daher stellt das Ausschalten dieses Schlüssels das alte Verhalten wieder her.

Owner in Team- oder Enterprise-Plänen können ihn organisationsweit über [serverseitig verwaltete Einstellungen](https://code.claude.com/docs/de/server-managed-settings.md) bereitstellen. Wenn verwaltete Einstellungen den Schlüssel setzen, wird `/fast on` außerhalb interaktiver Terminal-Sitzungen abgelehnt und meldet, dass Ihre Organisation den Fast-Modus deaktiviert hat. Das umfasst den [nicht interaktiven Modus](https://code.claude.com/docs/de/headless.md), die [VS Code-Erweiterung](https://code.claude.com/docs/de/vs-code.md) und [Cloud-Sitzungen](https://code.claude.com/docs/de/claude-code-on-the-web.md).

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: Boolean
  * `true`: ein gespeichertes `fastMode: true` aktiviert den Fast-Modus nicht mehr beim Sitzungsstart, daher führt jede Person `/fast` in jeder Sitzung aus, in der sie ihn möchte; ein mit `--settings` übergebenes `fastMode: true` zählt weiterhin für diese Sitzung, es sei denn, verwaltete Einstellungen setzen diesen Schlüssel
  * `false`: ein gespeichertes `fastMode: true` aktiviert den Fast-Modus zu Beginn jeder späteren Sitzung
* **Standard**: `false`

```json settings.json theme={null}
{
  "fastModePerSessionOptIn": true
}
```

Siehe [Opt-in pro Sitzung erforderlich](https://code.claude.com/docs/de/fast-mode.md#require-per-session-opt-in).

### `language`

Lassen Sie Claude standardmäßig in einer anderen Sprache als Englisch antworten. Es gibt keine feste Liste für Antworten: Claude Code übergibt den Wert wörtlich an Claude als Anweisung, immer in dieser Sprache zu antworten, daher funktioniert jeder Sprachname, den Claude lesen kann. Claude Code überprüft den Wert nicht, daher erreicht ein falsch geschriebener Name Claude so, wie er geschrieben ist, anstatt einen Fehler zu erzeugen. Derselbe Wert legt die Sprache für das [Sprachdiktat](https://code.claude.com/docs/de/voice-dictation.md#change-the-dictation-language) fest, das eine feste Liste von [unterstützten Diktiersprachen](https://code.claude.com/docs/de/voice-dictation.md#change-the-dictation-language) hat, sowie für automatisch generierte Sitzungstitel.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: String, jeder Sprachname, wie `"japanese"`, `"spanish"` oder `"french"`; Claude Code überprüft ihn nicht
* **Standard**: nicht gesetzt; Sitzungstitel entsprechen dann der Sprache Ihrer Konversation

```json settings.json theme={null}
{
  "language": "japanese"
}
```

### `maxEffortLevel`

Begrenzen Sie die [Effort-Stufe](https://code.claude.com/docs/de/model-config.md#adjust-effort-level), die eine Sitzung verwenden kann, wobei niedrigere Stufen verfügbar bleiben. Jede höhere Stufe läuft stattdessen mit der Obergrenze, einschließlich einer Stufe aus `/effort`, der Auswahl `/model`, `--effort`, [`CLAUDE_CODE_EFFORT_LEVEL`](https://code.claude.com/docs/de/env-vars), dem Frontmatter-Feld `effort` eines Skills oder Subagenten oder dem eigenen Standard des Modells. Claude Code wendet die Obergrenze vor jeder Anfrage selbst an, daher gilt sie bei jedem Provider, einschließlich Amazon Bedrock, Google Cloud's Agent Platform und Microsoft Foundry. Erfordert Claude Code v2.1.267 oder später.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes). Stellen Sie ihn in verwalteten Einstellungen bereit, um ihn für eine Organisation durchzusetzen. Wenn mehrere Geltungsbereiche eine Obergrenze setzen, gilt die niedrigste, daher kann eine in einem Geltungsbereich gesetzte Obergrenze nicht von einem anderen angehoben werden
* **Typ**: String, einer von `"low"`, `"medium"`, `"high"`, `"xhigh"` oder `"max"`. Ein Wert `"max"` setzt keine Obergrenze
* **Standard**: nicht gesetzt, daher gilt keine Obergrenze
* **Obergrenzen pro Modell**: Fügen Sie `maxEffortLevel` zum [`modelSettings`](#modelsettings)-Eintrag eines Modells hinzu. Dieser Eintrag ersetzt diesen Schlüssel für das Modell nur innerhalb der Einstellungsquelle, die beide setzt, wie Ihre Benutzereinstellungen oder eine [verwaltete Quelle](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources). Setzen Sie dort `"max"`, um das Modell von der Obergrenze dieser Quelle auszunehmen; Claude Code wendet weiterhin Obergrenzen aus anderen Quellen an

Dieses Beispiel begrenzt jedes Modell auf `medium` und nimmt Sonnet 4.6 aus:

```json settings.json theme={null}
{
  "maxEffortLevel": "medium",
  "modelSettings": {
    "claude-sonnet-4-6": {
      "maxEffortLevel": "max"
    }
  }
}
```

Wenn Ihre Organisation zusätzlich ein [Effort-Limit](https://code.claude.com/docs/de/model-config.md#organization-effort-limits) für ein Modell setzt, gilt die niedrigere der beiden Obergrenzen.

### `model`

Legen Sie das Modell fest, das jede neue Sitzung verwendet, damit Sie nicht jedes Mal mit `/model` eines auswählen müssen. Das Festlegen hier hindert Sie nicht daran, während der Sitzung zu wechseln. Wenn Ihr Admin ein [Organisations-Standardmodell](https://code.claude.com/docs/de/model-config.md#organization-default-model) gesetzt hat, um die Benutzerauswahl zu überschreiben, erhalten Sie dieses Modell, auch wenn Sie diesen Schlüssel in Benutzer-, Projekt- oder lokalen Einstellungen setzen.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: String, ein Modellalias oder eine vollständige Modell-ID
* **Standard**: nicht gesetzt, daher verwendet Claude Code das Standardmodell Ihres Kontos
* **Überschreibungen pro Sitzung**: `--model` hat Vorrang vor [`ANTHROPIC_MODEL`](https://code.claude.com/docs/de/env-vars), und beide haben für eine Sitzung Vorrang vor diesem Schlüssel, auch vor einem verwalteten `model`; eine [`availableModels`](#availablemodels)-Liste gilt weiterhin für die Auswahl

```json settings.json theme={null}
{
  "model": "claude-sonnet-5"
}
```

Ein Wert hier hat Vorrang vor [`ANTHROPIC_DEFAULT_MODEL`](https://code.claude.com/docs/de/model-config#set-a-default-model-for-new-sessions), das Claude Code nur verwendet, wenn nichts anderes ein Modell auswählt.

### `modelOverrides`

Ordnen Sie Anthropic-Modell-IDs providerspezifischen Modell-IDs zu, wie ARNs von Amazon Bedrock-Inferenzprofilen. Jeder Eintrag der Modellauswahl verwendet dann seinen zugeordneten Wert beim Aufruf der Provider-API. Administratoren verwenden dies auf [Amazon Bedrock, Google Cloud's Agent Platform und Microsoft Foundry](https://code.claude.com/docs/de/model-config.md#override-model-ids-per-version), um jede Modellversion für Governance, Kostenzuordnung oder regionales Routing an ein bestimmtes Inferenzprofil, einen Versionsnamen oder eine Bereitstellung zu leiten.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: Objekt, das Modell-IDs Provider-Modell-IDs zuordnet
* **Standard**: nicht gesetzt

Dieses Beispiel leitet jeden Aufruf für Opus 4.6 an das benannte Bedrock-Inferenzprofil:

```json settings.json theme={null}
{
  "modelOverrides": {
    "claude-opus-4-6": "arn:aws:bedrock:us-east-1:123456789012:inference-profile/example"
  }
}
```

Siehe [Modell-IDs pro Version überschreiben](https://code.claude.com/docs/de/model-config.md#override-model-ids-per-version).

### `modelPicker`

Listen Sie die Modelle auf, die die Auswahl `/model` anbietet, in der Reihenfolge, in der Sie sie schreiben, und unter Bezeichnungen, die Sie wählen, sodass die Auswahl die Modelle aufführt, die Ihre Organisation verwendet, nach der integrierten Auswahl oder an ihrer Stelle. Das `model` jeder Zeile wird wörtlich übernommen, daher akzeptiert es alles, was `--model` akzeptiert: einen Alias wie `opus`, eine Anthropic-Modell-ID oder eine ID im Provider-Format für Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry oder ein LLM-Gateway. Erfordert Claude Code v2.1.242 oder später.

* **Geltungsbereich**: [`Benutzer oder verwaltet`](#scopes). Claude Code liest den Schlüssel aus verwalteten Einstellungen, `--settings` und Benutzereinstellungen und ignoriert ihn in Projekt- und lokalen Einstellungen, damit ein Repository, das Sie klonen, die Auswahl nicht umbenennen kann. Die höchste dieser drei Quellen, die den Schlüssel setzt, liefert die gesamte Auswahl, und Claude Code kombiniert nie Auswahllisten aus zwei Quellen.
* **Typ**: Objekt mit einem Array `options` von Zeilen und einem optionalen Boolean `replaceBuiltInOptions`
* **Standard**: nicht gesetzt, daher zeigt die Auswahl die integrierte Auswahl

Dieses Beispiel fügt nach der integrierten Auswahl zwei Bedrock-Bereitstellungen unter Namen hinzu, die Ihr Team kennt:

```json managed-settings.json theme={null}
{
  "modelPicker": {
    "options": [
      { "model": "us.anthropic.claude-opus-4-8", "label": "Opus (production)" },
      {
        "model": "us.anthropic.claude-sonnet-4-6",
        "label": "Sonnet (production)",
        "description": "Day-to-day work"
      }
    ]
  }
}
```

#### Felder für `modelPicker`

Der Schlüssel hat zwei Felder: eines für die Zeilen selbst und eines dafür, ob sie die integrierte Auswahl ersetzen oder ergänzen.

| Feld | Typ | Funktion |
| :- | :- | :- |
| `options` | Array von Zeilen, jede mit einem erforderlichen `model` und optionalen `label`, `description` und `behavesAs` | Die Zeilen, die die Auswahl anzeigt, in dieser Reihenfolge, außer dass eine ausgegraute Zeile nach unten verschoben wird. Ohne `label` betitelt Claude Code die Zeile mit dem integrierten Namen für ein Modell, das es kennt, andernfalls mit der Modell-ID, und ohne `description` schreibt es eine generische zweite Zeile |
| `replaceBuiltInOptions` | Boolean, Standard `false` | Setzen Sie es auf `true`, um nur diese Zeilen, **Standard** und eine Zeile für das Modell anzuzeigen, das die Sitzung bereits verwendet. Lassen Sie es ungesetzt, um diese Zeilen nach der integrierten Auswahl hinzuzufügen |

Ein Eintrag in `options` kann neben seinem `model` auch einen optionalen String `behavesAs` enthalten, was v2.1.257 oder später erfordert. Setzen Sie ihn auf die ID eines Modells, das Ihre Claude Code-Version bereits kennt, wie `claude-opus-4-8`, bei einem Eintrag, dessen `model` neuer als Ihre Version ist. Claude Code wendet dann die Fähigkeiten und Effort-Standards dieses bekannten Modells auf den Eintrag an, anstatt sein Modell als unbekannt zu behandeln. Die Bezeichnung des Eintrags und die Modell-ID, die Claude Code in Anfragen sendet, ändern sich nicht.

Wenn `replaceBuiltInOptions` aktiviert ist, blendet Claude Code alle anderen Zeilen aus: die integrierte Auswahl, die Zeilen, die es für [`availableModels`](#availablemodels)-Einträge hinzufügt, die Modelle, die die [Gateway-Erkennung](https://code.claude.com/docs/de/llm-gateway-protocol.md#model-discovery) gefunden hat, und [`ANTHROPIC_CUSTOM_MODEL_OPTION`](https://code.claude.com/docs/de/model-config#add-a-custom-model-option). Wenn es deaktiviert ist, überspringt Claude Code ein aufgelistetes Modell, das die integrierte Auswahl bereits abdeckt. Eine Bezeichnung ändert, was die Auswahl anzeigt, nicht welches Modell Claude Code ausführt.

Eine [`availableModels`](#availablemodels)-Allowlist gilt weiterhin für diese Zeilen. Bevor Sie ein aufgelistetes Modell zur Allowlist hinzufügen, lesen Sie [Zusammenführungsverhalten](https://code.claude.com/docs/de/model-config.md#merge-behavior): Eine spezifische Modell-ID schränkt den Wildcard-Eintrag ihrer Familie ein. Claude Code prüft außerdem jede Zeile gegen die Sitzung, bevor es die Auswahl anzeigt:

* **Entfernt**: eine Zeile, die Claude Code nicht bedienen kann, wie ein eingestelltes Modell oder ein Modell, auf das Ihre Organisation keinen Zugriff hat
* **Ausgegraut**: eine Zeile, die Sie noch nicht auswählen können, mit Angabe des Grundes
* **Keine Zeile bleibt übrig**: Claude Code behält die integrierte Auswahl, wie üblich durch die Allowlist gefiltert

Claude Code entfernt eine Zeile, die es nicht parsen kann, und behält den Rest. Siehe [Fehlerhafte Einstellungsdatei beheben](https://code.claude.com/docs/de/settings.md#fix-a-broken-settings-file).

### `modelPricing`

Melden Sie Ausgaben zu den Preisen, die Ihre Organisation zahlt, anstatt zum Listenpreis. Setzen Sie den Schlüssel, wenn Ihre Organisation vertraglich vereinbarte Preise hat, damit die Dollarbeträge, die Entwickler sehen, Ihrer Rechnung entsprechen. Claude Code wendet die Preise in `/usage`, der [Statuszeile](https://code.claude.com/docs/de/statusline.md), dem `total_cost_usd` des Agent SDK, dem Limit [`--max-budget-usd`](https://code.claude.com/docs/de/cli-reference) sowie der Kostenmetrik und den Ereignissen von [OpenTelemetry](https://code.claude.com/docs/de/monitoring-usage.md) an. Sie liefern die Preise: Claude Code liest sie nicht aus Ihrem Vertrag oder der Claude Console. Erfordert Claude Code v2.1.242 oder später.

* **Geltungsbereich**: [`Verwaltet`](#scopes). Stellen Sie den Schlüssel über serverseitig verwaltete Einstellungen, eine MDM-Richtlinie, eine Datei `managed-settings.json` oder ein [Richtlinien-Hilfsprogramm](https://code.claude.com/docs/de/managed-settings.md#compute-the-policy-with-a-helper-program) bereit. Claude Code ignoriert ihn in Benutzer-, Projekt- und lokalen Einstellungen, in `--settings` und unter Windows in der vom Benutzer beschreibbaren [HKCU-Registrierung](https://code.claude.com/docs/de/managed-settings.md#where-each-mechanism-stores-the-policy). Mit serverseitig verwalteten Einstellungen meldet jede Sitzung Kosten zum Listenpreis, bis der [Einstellungsabruf](https://code.claude.com/docs/de/server-managed-settings.md#fetch-and-caching-behavior) dieser Sitzung die Einstellung bestätigt hat. Eine Host-Anwendung, die Claude Code einbettet und [`CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST`](https://code.claude.com/docs/de/env-vars) setzt, kann über die SDK-Option [`managedSettings`](https://code.claude.com/docs/de/agent-sdk/typescript#options) eine eigene Tabelle liefern, die Claude Code nur verwendet, wenn keine verwaltete Quelle den Schlüssel setzt, und nur in Claude Code v2.1.246 oder später.
* **Typ**: Objekt mit einem optionalen `multiplier` und einer optionalen Zuordnung `overrides`
* **Standard**: nicht gesetzt, daher meldet Claude Code den Listenpreis, es sei denn, eine Host-Anwendung liefert eine Tabelle

Setzen Sie nur `multiplier` für einen pauschalen Rabatt oder Aufschlag, nur `overrides` für Preise pro Modell oder beides.

Dieses Beispiel setzt vertraglich vereinbarte Preise für Sonnet 4.6 und reduziert dann jeden Betrag, einschließlich der Sonnet-Zeile, um 15 %:

```json managed-settings.json theme={null}
{
  "modelPricing": {
    "multiplier": 0.85,
    "overrides": {
      "claude-sonnet-4-6": {
        "input": 2.4,
        "output": 12,
        "cacheRead": 0.24,
        "cacheWrite": 3
      }
    }
  }
}
```

Setzen Sie `multiplier` auf einen Wert über 1, bis maximal 10, um jeden Betrag mit einem Aufschlag zu versehen. Ein Aufschlag erfordert Claude Code v2.1.271 oder später. Frühere Versionen ignorieren einen `multiplier` über 1 mit einer Warnung und behalten den Rest der Einstellung.

Die Schritte, einschließlich der Bestätigung, dass die Preise wirksam sind, finden Sie unter [Ausgaben zu Ihren vertraglich vereinbarten Preisen melden](https://code.claude.com/docs/de/costs.md#report-spend-at-your-contracted-rates).

#### Felder für `modelPricing`

| Feld | Typ | Funktion |
| :- | :- | :- |
| `multiplier` | Zahl größer als 0 und höchstens 10 | Skaliert alle Kosten, die Claude Code berechnet, unabhängig davon, ob eine `overrides`-Zeile sie abdeckt. Unter 1 ist ein Rabatt, über 1 ein Aufschlag |
| `overrides` | Zuordnung von Modell-ID zu einem Preisobjekt mit `input`, `output`, `cacheRead` und `cacheWrite`, jeweils 0 bis 10000 | Die Preise in USD pro Million Token für dieses Modell, alle vier erforderlich. `cacheWrite` deckt sowohl Cache-Schreibvorgänge mit fünf Minuten als auch mit einer Stunde ab. Siehe [Für welche Modelle eine Zeile gilt](#which-models-a-modelpricing-row-applies-to) |

Claude Code verwendet die Preise einer Zeile genau so, wie Sie sie geschrieben haben, ohne den Fast-Modus-Aufschlag oder den [Preis für reine US-Inferenz](https://platform.claude.com/docs/en/about-claude/pricing) hinzuzufügen. Wenn Sie auch `multiplier` setzen, wendet Claude Code ihn zusätzlich auf die Preise der Zeile an. Claude Code entfernt eine Zeile mit einem Preis, den es nicht parsen kann, oder einen `multiplier`, den es nicht parsen kann, und behält den Rest; siehe [Fehlerhafte Einstellungsdatei beheben](https://code.claude.com/docs/de/settings.md#fix-a-broken-settings-file).

#### Für welche Modelle eine `modelPricing`-Zeile gilt

Claude Code bestimmt anhand des Schlüssels der Zeile, für welche Modelle eine Zeile gilt:

* **Die ID eines integrierten Modells**: ein Schlüssel, den Claude Code selbst für ein integriertes Modell verwendet, sei es die eigene ID des Modells, wie `claude-sonnet-4-6`, oder seine Bedrock-, Agent Platform- oder Foundry-ID. Claude Code wendet die Zeile auf jede datierte Snapshot-ID und jede providerspezifische ID dieses Modells an.
* **Jeder andere Schlüssel**: ein Schlüssel, der nicht die ID eines integrierten Modells ist, wie ein Gateway-Modellalias. Claude Code wendet die Zeile nur auf genau diese ID an. Wenn eine Modell-ID genau mit einem Ihrer Schlüssel übereinstimmt und zugleich unter eine Zeile fällt, deren Schlüssel die ID eines integrierten Modells ist, verwendet Claude Code die genaue Übereinstimmung.
* **Ein Bedrock-Anwendungsinferenzprofil**: Sobald Claude Code das Profil über Ihre Zuordnung [`modelOverrides`](#modeloverrides) oder die [Abfrage `bedrock:GetInferenceProfile`](https://code.claude.com/docs/de/amazon-bedrock#iam-configuration) zu dem Modell aufgelöst hat, an das es weiterleitet, wendet Claude Code die Zeile dieses Modells auf das Profil an.

### `modelSettings`

Speichern Sie eine [Effort-Stufe](https://code.claude.com/docs/de/model-config.md#adjust-effort-level) für jedes Modell, das Sie verwenden. Erfordert Claude Code v2.1.251 oder später.

Wenn Sie in einer interaktiven Sitzung auf Ihrem Computer `low`, `medium`, `high` oder `xhigh` mit `/effort` oder dem Effort-Schieberegler der Auswahl `/model` als Ihren Standard speichern, schreibt Claude Code diese Stufe hier unter dem Modell, das Sie verwenden, daher bearbeiten Sie diesen Schlüssel selten selbst. Wenn Sie eine dieser Stufen in der [Modellauswahl der VS Code-Erweiterung](https://code.claude.com/docs/de/vs-code.md#use-the-prompt-box) auswählen, speichert Claude Code sie auf dieselbe Weise hier. Der Eintrag [`effortLevel`](#effortlevel) listet die Sitzungen auf, in denen `/effort` nur für diese Sitzung gilt.

Bearbeiten Sie den Schlüssel manuell, um eine gespeicherte Stufe zu ändern oder zu entfernen.

Ein `effortLevel` eines Modells hier hat Vorrang vor dem `effortLevel` der obersten Ebene ([`effortLevel`](#effortlevel)) in derselben Einstellungsdatei. Dateiübergreifend löst Claude Code jedes Modell separat auf: Die [Einstellungsdatei](https://code.claude.com/docs/de/settings.md#settings-precedence) mit dem höchsten Vorrang, die entweder ein `effortLevel` für dieses Modell oder ein `effortLevel` der obersten Ebene setzt, das [für dieses Modell gilt](#effortlevel), entscheidet, daher hat ein `effortLevel` in verwalteten Einstellungen Vorrang vor einer Stufe, die Sie in Benutzereinstellungen gespeichert haben. [Effort-Stufe anpassen](https://code.claude.com/docs/de/model-config.md#adjust-effort-level) listet auf, was eine gespeicherte Stufe sonst noch überschreiben kann, wie `--effort` beim Start.

Um den Effort eines Modells zu begrenzen, anstatt seine Stufe festzulegen, fügen Sie dem Eintrag dieses Modells ein Feld [`maxEffortLevel`](#maxeffortlevel) hinzu. Das Feld erfordert Claude Code v2.1.267 oder später.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: Objekt, das einen Modellnamen einem Objekt mit beliebigen dieser Felder zuordnet:
  * `effortLevel`: einer von `"low"`, `"medium"`, `"high"` oder `"xhigh"`
  * [`maxEffortLevel`](#maxeffortlevel): die höchste Effort-Stufe, mit der das Modell laufen darf
  * `autoCompactWindow`: eine Anzahl von Token von `100000` bis `1000000` oder `"auto"` für das auf das Modell abgestimmte Fenster. [`/autocompact`](https://code.claude.com/docs/de/model-config#set-the-auto-compact-window) speichert hier. Für dieses Modell hat der Wert Vorrang vor einem [`autoCompactWindow`](#autocompactwindow) der obersten Ebene in derselben Einstellungsdatei. Erfordert Claude Code v2.1.288 oder später
* **Standard**: nicht gesetzt

Claude Code schreibt jeden Eintrag unter dem kanonischen Namen des Modells, wie `claude-opus-5-5`, und ordnet den Alias, die IDs mit Datumssuffix, `[1m]` und erkannte providerspezifische IDs dieses Modells demselben Eintrag zu.

Dieses Beispiel hält Opus 5.5 auf `high`, während andere Modelle ihre eigenen gespeicherten oder Standardstufen verwenden:

```json settings.json theme={null}
{
  "modelSettings": {
    "claude-opus-5-5": {
      "effortLevel": "high"
    }
  }
}
```

Führen Sie `/effort auto` aus, um Ihre gespeicherte Stufe für das Modell zu löschen, das Sie verwenden. Claude Code lässt die anderen Einträge und jedes `effortLevel` der obersten Ebene bestehen.

### `outputStyle`

Wählen Sie einen [Ausgabestil](https://code.claude.com/docs/de/output-styles.md) nach Namen aus. Ein Ausgabestil ist ein gespeicherter Satz von Anweisungen, der Claudes Rolle, Ton und Ausgabeformat ändert, wie die integrierten Stile Explanatory und Learning oder ein Stil, den Sie selbst geschrieben haben.

Wenn Sie diesen Schlüssel während einer Sitzung ändern, verwendet Claude den neuen Stil ab Ihrer nächsten Nachricht. Was diese Nachricht beim Prompt-Caching kostet, erfahren Sie unter [Ausgabestil ändern](https://code.claude.com/docs/de/prompt-caching.md#changing-output-style). Vor v2.1.251 wurde die Änderung erst wirksam, nachdem Sie `/clear` ausgeführt oder eine neue Sitzung gestartet hatten.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: String, der Name eines [integrierten](https://code.claude.com/docs/de/output-styles.md#built-in-output-styles) oder [benutzerdefinierten](https://code.claude.com/docs/de/output-styles.md#create-a-custom-output-style) Ausgabestils
* **Standard**: nicht gesetzt, daher verwendet Claude Code den Standardstil

Dieses Beispiel wählt den integrierten Stil Explanatory, der zwischen Aufgaben erklärende Einblicke hinzufügt:

```json settings.json theme={null}
{
  "outputStyle": "Explanatory"
}
```

### `promptCacheTtl`

Legen Sie fest, wie lange der [Prompt-Cache](https://code.claude.com/docs/de/prompt-caching.md) die Hauptkonversation vorhält. Dieser Schlüssel gilt für Ihre interaktiven, `-p`- und Agent SDK-Turns sowie für die Hilfsanfragen, die Claude Code direkt mit ihnen ausführt. Die einstündige Lebensdauer hält den Cache über längere Pausen warm, und die API [berechnet jeden Cache-Schreibvorgang zu einem höheren Preis](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#pricing) als bei der fünfminütigen Lebensdauer. Erfordert Claude Code v2.1.242 oder später.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: String, einer von:
  * `"5m"`: der Cache hält fünf Minuten
  * `"1h"`: der Cache hält eine Stunde
* **Standard**: nicht gesetzt, daher erhält jede Anfrage der Hauptkonversation [ihre Standardlebensdauer](https://code.claude.com/docs/de/prompt-caching.md#which-ttl-each-request-gets)
* **Überschreibungen pro Sitzung**: [`FORCE_PROMPT_CACHING_5M`](https://code.claude.com/docs/de/env-vars) hat Vorrang vor allem anderen, dann [`CLAUDE_CODE_PROMPT_CACHE_TTL`](https://code.claude.com/docs/de/env-vars), dann dieser Schlüssel und zuletzt [`ENABLE_PROMPT_CACHING_1H`](https://code.claude.com/docs/de/env-vars)

Dieses Beispiel hält die Hauptkonversation auf der einstündigen Lebensdauer und lässt Subagenten bei fünf Minuten:

```json settings.json theme={null}
{
  "promptCacheTtl": "1h",
  "subagentPromptCacheTtl": "5m"
}
```

Was jede Lebensdauer kostet, erfahren Sie unter [Cache-Lebensdauer](https://code.claude.com/docs/de/prompt-caching.md#cache-lifetime).

### `showThinkingSummaries`

Zeigen Sie Zusammenfassungen von Claudes [Extended Thinking](https://code.claude.com/docs/de/model-config.md#extended-thinking) in interaktiven Sitzungen an. Setzen Sie den Schlüssel, wenn Sie die vollständigen Zusammenfassungen sehen möchten, wenn Sie Thinking mit `Ctrl+O` aufklappen. Wenn er nicht gesetzt oder `false` ist, schwärzt die Anthropic API Thinking-Blöcke und Claude Code zeigt einen zugeklappten Platzhalter.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: Boolean
  * `true`: Sie sehen vollständige Thinking-Zusammenfassungen, wenn Sie Thinking mit `Ctrl+O` aufklappen
  * `false`: die Anthropic API schwärzt Thinking-Blöcke und Claude Code zeigt einen zugeklappten Platzhalter
* **Standard**: `false`

```json settings.json theme={null}
{
  "showThinkingSummaries": true
}
```

Die Schwärzung ändert nur, was Sie sehen, nicht was das Modell generiert. Um die Thinking-Kosten zu senken, [verringern Sie stattdessen das Budget oder deaktivieren Sie Thinking](https://code.claude.com/docs/de/model-config.md#extended-thinking).

### `subagentPromptCacheTtl`

Legen Sie fest, wie lange der [Prompt-Cache](https://code.claude.com/docs/de/prompt-caching.md) die Anfragen vorhält, die Claude Code außerhalb der Hauptkonversation stellt. Dieser Schlüssel gilt für [Subagenten](https://code.claude.com/docs/de/sub-agents.md), [Workflows](https://code.claude.com/docs/de/workflows.md) und die eigenen Hintergrund- und Hilfsanfragen von Claude Code, wie Komprimierung und Sitzungstitel. Die einstündige Lebensdauer hält den Cache über längere Pausen warm, und die API [berechnet jeden Cache-Schreibvorgang zu einem höheren Preis](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#pricing) als bei der fünfminütigen Lebensdauer. Erfordert Claude Code v2.1.242 oder später.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: String, einer von:
  * `"5m"`: der Cache hält fünf Minuten
  * `"1h"`: der Cache hält eine Stunde
* **Standard**: nicht gesetzt, daher erhält jede dieser Anfragen [ihre Standardlebensdauer](https://code.claude.com/docs/de/prompt-caching.md#which-ttl-each-request-gets)
* **Überschreibungen pro Sitzung**: [`FORCE_PROMPT_CACHING_5M`](https://code.claude.com/docs/de/env-vars) hat Vorrang vor allem anderen, dann [`CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL`](https://code.claude.com/docs/de/env-vars), dann dieser Schlüssel, dann [`ENABLE_PROMPT_CACHING_1H`](https://code.claude.com/docs/de/env-vars), das für jede Anfrage die einstündige Lebensdauer anfordert. Wo der Frontmatter-Wert eines Subagenten selbst in dieser Rangfolge steht, erfahren Sie unter [Die TTL selbst wählen](https://code.claude.com/docs/de/prompt-caching.md#choose-the-ttl-yourself)

Dieses Beispiel gibt Subagenten und den anderen Anfragen außerhalb der Hauptkonversation die einstündige Lebensdauer:

```json settings.json theme={null}
{
  "subagentPromptCacheTtl": "1h"
}
```

Dieser Schlüssel deckt die Anfragen ab, die [`promptCacheTtl`](#promptcachettl) nicht abdeckt, daher setzen Sie beide, um für jede Anfrage von Claude Code eine Lebensdauer festzulegen. Wie sich der Cache eines Subagenten von dem der Hauptkonversation unterscheidet, erfahren Sie unter [Subagenten und der Cache](https://code.claude.com/docs/de/prompt-caching.md#subagents-and-the-cache).

### `switchModelsOnFlag`

Legen Sie fest, was passiert, wenn ein [Sicherheits-Klassifikator eine Anfrage kennzeichnet](https://code.claude.com/docs/de/model-config.md#automatic-model-fallback): zum Fallback-Modell wechseln und fortfahren oder pausieren, damit Sie zwischen Wechseln und Bearbeiten des Prompts wählen können.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes). Erscheint in `/config` als **Modelle wechseln, wenn eine Nachricht gekennzeichnet ist**, mit den Optionen **Automatisch wechseln** und **Jedes Mal fragen**.
* **Typ**: Boolean
  * `true`: Claude Code wechselt zum Fallback-Modell und fährt fort
  * `false`: In einer interaktiven Sitzung pausiert Claude Code, damit Sie zwischen Wechseln und Bearbeiten des Prompts wählen können; wo kein Dialog angezeigt werden kann, wie bei einem `-p`-Lauf, endet die gekennzeichnete Anfrage mit einem Fehler
* **Standard**: nicht gesetzt. Claude Code wechselt automatisch, kann in einer interaktiven Sitzung aber [zuerst nachfragen](https://code.claude.com/docs/de/model-config.md#ask-before-switching)

```json settings.json theme={null}
{
  "switchModelsOnFlag": false
}
```

Siehe [Vor dem Wechsel fragen](https://code.claude.com/docs/de/model-config.md#ask-before-switching).

### `ultracode`

Starten Sie Sitzungen mit aktiviertem [Ultracode](https://code.claude.com/docs/de/workflows.md#let-claude-decide-with-ultracode). Wenn es aktiviert ist, plant Claude für jede substanzielle Aufgabe einen Workflow, anstatt darauf zu warten, dass Sie darum bitten. Claude plant Workflows nur, wenn [dynamische Workflows](https://code.claude.com/docs/de/workflows.md) für Sie aktiviert sind und Ihr Modell den Effort `xhigh` unterstützt. Der Schlüssel ändert die Effort-Stufe der Sitzung nicht: Ultracode läuft mit der Stufe, die die Sitzung verwendet. Claude Code liest diesen Schlüssel, schreibt ihn aber nie: `/effort ultracode` aktiviert Ultracode nur für die aktuelle Sitzung.

* **Geltungsbereich**: [`Beliebige Datei`](#scopes)
* **Typ**: Boolean
  * `true`: Sitzungen starten mit aktiviertem Ultracode, wenn dynamische Workflows für Sie aktiviert sind und Ihr Modell `xhigh` unterstützt
  * `false`: Sitzungen starten mit deaktiviertem Ultracode
* **Standard**: nicht gesetzt, daher ist Ultracode deaktiviert
* **Überschreibungen pro Sitzung**: `/effort ultracode` aktiviert Ultracode für eine Sitzung ohne diesen Schlüssel, und `/effort ultracode off` deaktiviert es für eine Sitzung, wenn dieser Schlüssel `true` ist. Das Flag `--effort ultracode` aktiviert es ebenfalls für eine Sitzung, mit dem Effort `xhigh`

```json settings.json theme={null}
{
  "ultracode": true
}
```

Die Effort-Stufe der Sitzung ergibt sich aus [`effortLevel`](#effortlevel), [`modelSettings`](#modelsettings) und den anderen [Effort-Quellen](https://code.claude.com/docs/de/model-config.md#adjust-effort-level), und eine [Effort-Obergrenze](https://code.claude.com/docs/de/model-config.md#organization-effort-limits) wie [`maxEffortLevel`](#maxeffortlevel) senkt diese Stufe, ohne Ultracode auszuschalten. Dies und die Form `/effort ultracode off` erfordern Claude Code v2.1.284 oder später. Vor v2.1.284 ließ `ultracode: true` die Sitzung mit dem Effort `xhigh` laufen, und eine Effort-Obergrenze unter `xhigh` hielt Ultracode ausgeschaltet. Eine Agent SDK-Steuerungsanfrage `apply_flag_settings` akzeptiert den Schlüssel ebenfalls.

## Berechtigungseinstellungen

Entscheiden Sie, was Claude ohne Nachfrage tun kann, in welchem Berechtigungsmodus eine Sitzung startet, und was der Klassifikator des Auto-Modus zulässt. Informationen zur Regelsyntax und zum Berechtigungsmodell finden Sie unter [Berechtigungen konfigurieren](https://code.claude.com/docs/de/permissions.md).

### `allowManagedPermissionRulesOnly`

Machen Sie verwaltete Einstellungen zur einzigen Quelle für Berechtigungsregeln. Claude Code ignoriert dann `allow`-, `ask`- und `deny`-Regeln in Benutzer-, Projekt-, lokalen und `--settings`-Dateien, ignoriert `--allowedTools`, blendet die Optionen zum Immer-Zulassen in Berechtigungsabfragen aus und speichert keine neuen Regeln.

Wenn [übergeordnete Einstellungen von einem Embedding-Host](https://code.claude.com/docs/de/managed-settings.md#let-an-embedding-host-add-policy) gelten, behandelt Claude Code diese als Teil der verwalteten Ebene. Es verwirft deren `allow`-Regeln und `additionalDirectories` und behält deren `deny`- und `ask`-Regeln bei, außer `Read`- und `Edit`-Regeln, deren Muster mit `!` beginnt. Ein Host kann Pfade aus den verwalteten Regeln nicht mit einer `!`-Regel ausschneiden, unabhängig davon, ob Sie diesen Schlüssel setzen oder nicht.

`--disallowedTools`-Regeln und die `deny`- und `ask`-Regeln der aktuellen Sitzung gelten weiterhin, auch nachdem Claude Code die Einstellungen während der Sitzung neu lädt. Sie beschränken nur, daher können sie nicht erweitern, was die verwalteten Regeln gewähren. Vor v2.1.257 verwarf Claude Code diese Befehlszeilen- und Sitzungsregeln beim ersten Neuladen der Einstellungen.

Informationen dazu, was ein `!`-Muster in einer `--disallowedTools`- oder Sitzungsregel ausschneiden kann, finden Sie unter [Read- und Edit-Regeln](https://code.claude.com/docs/de/permissions.md#read-and-edit).

Wenn Sie diesen Schlüssel setzen, ignoriert Claude Code v2.1.282 oder später außerdem das [`allowed-tools`](https://code.claude.com/docs/de/skills#pre-approve-tools-for-a-skill)-Frontmatter in Skills und `.claude/commands/`-Dateien aus diesen Quellen:

* Das `.claude/`-Verzeichnis eines Repositorys
* Ihre Verzeichnisse `~/.claude/skills/` und `~/.claude/commands/`, einschließlich [von claude.ai synchronisierter Skills](https://code.claude.com/docs/de/skills.md#where-synced-skills-load)
* Ein `--add-dir`-Verzeichnis
* [Plugins, die mit einem `.claude-plugin`-Manifest deklariert sind](https://code.claude.com/docs/de/plugins/loading#plugins-shared-through-a-repository), innerhalb von `~/.claude/skills/` oder dem `.claude/skills/` des Projekts
* Plugins, die nur für eine Sitzung geladen werden und deren IDs auf [`@inline`](https://code.claude.com/docs/de/plugins/loading#find-where-a-plugin-came-from) enden, wenn alle folgenden Bedingungen erfüllt sind:
  * Die Sitzung ist eine [Code-Sitzung](https://code.claude.com/docs/de/desktop.md#environment-configuration) oder [Cowork-Sitzung](https://code.claude.com/docs/de/managed-settings.md#where-and-when-a-policy-applies), jedoch keine Cloud-Sitzung, für die die Claude Desktop-App selbst Claude Code startet
  * Ihre verwalteten Einstellungen setzen den Schlüssel, nicht nur die [übergeordneten Einstellungen](https://code.claude.com/docs/de/managed-settings.md#let-an-embedding-host-add-policy) eines Embedding-Hosts
  * Die Sitzung läuft mit Claude Code v2.1.305 oder später

Skills aus verwalteten Einstellungen und mitgelieferte Skills behalten ihr `allowed-tools`. `@inline`-Plugins außerhalb dieser Desktop-Sitzungen behalten ihres ebenfalls, außer einem Plugin namens [`anthropic-skills`](https://code.claude.com/docs/de/skills#names-reserved-for-synced-skills). Das `disallowed-tools` eines Skills gilt weiterhin. Was ein Entwickler sieht, wenn Claude Code das Feld ignoriert, erfahren Sie unter [Wenn nur verwaltete Berechtigungsregeln gelten](https://code.claude.com/docs/de/skills.md#when-only-managed-permission-rules-apply).

* **Geltungsbereich**: [`Managed`](#scopes)
* **Typ**: Boolean
  * `true`: verwaltete Einstellungen werden zur einzigen Quelle für Berechtigungsregeln
  * `false`: Claude Code wendet Berechtigungsregeln aus Benutzer-, Projekt-, lokalen und `--settings`-Dateien zusätzlich zu den verwalteten an
* **Standard**: nicht gesetzt, daher wendet Claude Code Berechtigungsregeln aus Benutzer-, Projekt- und lokalen Einstellungen sowie aus `--settings` zusätzlich zu den verwalteten an

```json managed-settings.json theme={null}
{
  "allowManagedPermissionRulesOnly": true
}
```

Dieser Schlüssel sperrt nicht die MCP-Server-Allowlist; verwenden Sie dazu [`allowManagedMcpServersOnly`](#allowmanagedmcpserversonly). Siehe [Nur verwaltete Einstellungen](https://code.claude.com/docs/de/managed-settings.md#managed-only-settings).

### `autoMode`

Fügen Sie Ihre eigenen Regeln zu dem hinzu, was der [Auto-Modus](https://code.claude.com/docs/de/permission-modes.md#eliminate-prompts-with-auto-mode)-Klassifikator blockiert und zulässt. Verwenden Sie es, um dem Klassifikator mitzuteilen, welchen Repos, Buckets und Domains Ihre Organisation vertraut, damit er alltägliche interne Vorgänge nicht mehr blockiert. Der Klassifikator wird mit [integrierten Allow- und Deny-Regeln](https://code.claude.com/docs/de/auto-mode-config.md#inspect-the-defaults-and-your-effective-config) ausgeliefert. Fügen Sie die Literalzeichenfolge `"$defaults"` in einem Array ein, um diese integrierten Regeln an dieser Position zu behalten und Ihre Regeln um sie herum hinzuzufügen; lassen Sie sie weg, um sie durch Ihre zu ersetzen.

* **Geltungsbereich**: [`User or managed`](#scopes)
* **Typ**: Objekt mit `environment`-, `allow`-, `soft_deny`- und `hard_deny`-Arrays von Prosa-Regeln sowie dem Boolean [`classifyAllShell`](#automode-classifyallshell)
* **Standard**: nicht gesetzt, daher verwendet der Klassifikator nur seine [integrierten Regeln](https://code.claude.com/docs/de/auto-mode-config.md#inspect-the-defaults-and-your-effective-config)

Dieses Beispiel behält die integrierten `soft_deny`-Regeln durch `"$defaults"` und fügt eine weitere hinzu, die `terraform apply` blockiert:

```json settings.json theme={null}
{
  "autoMode": {
    "soft_deny": ["$defaults", "Never run terraform apply"]
  }
}
```

Wenn mehr als eine dieser Dateien dasselbe Array setzt, verkettet Claude Code die Einträge. Informationen zum Regelformat und zur Anwendung der einzelnen Arrays finden Sie unter [Auto-Modus konfigurieren](https://code.claude.com/docs/de/auto-mode-config.md).

### `autoMode.classifyAllShell`

Senden Sie jeden Bash- und PowerShell-Befehl durch den Auto-Modus-Klassifikator, während der Auto-Modus aktiv ist. Standardmäßig setzt der Auto-Modus nur Allow-Regeln aus, die beliebigen Code ausführen könnten: Tool-weite und Wildcard-Regeln wie `Bash(*)` sowie Interpreter- oder Shell-Wrapper-Präfixe wie `Bash(python *)`. Ein Befehl, der einer anderen Allow-Regel entspricht, wie `Bash(npm test)`, überspringt den Klassifikator, es sei denn, er trägt [Pro-Befehl zulässige Domains](https://code.claude.com/docs/de/sandboxing.md#per-command-allowed-domains-in-auto-mode). Wenn er überspringt, kann ein destruktives Argument, das das Präfix der Regel nicht erwartet hat, ungesehen durchkommen. Das Setzen dieses Schlüssels setzt jede Shell-Allow-Regel für die Sitzung aus, damit der Klassifikator jeden Befehl sieht. Erfordert Claude Code v2.1.193 oder später.

* **Geltungsbereich**: [`User or managed`](#scopes). Wird überall dort gelesen, wo [`autoMode`](#automode) gelesen wird.
* **Typ**: Boolean
  * `true`: Während der Auto-Modus aktiv ist, sendet Claude Code jeden Bash- und PowerShell-Befehl durch den Klassifikator und setzt Ihre Shell-Allow-Regeln aus; außerhalb des Auto-Modus gelten die Regeln weiterhin
  * `false`: Der Auto-Modus setzt nur Allow-Regeln aus, die beliebigen Code ausführen könnten, wie `Bash(*)` und `Bash(python *)`; ein Befehl, der einer anderen Allow-Regel entspricht, überspringt den Klassifikator, es sei denn, er trägt [Pro-Befehl zulässige Domains](https://code.claude.com/docs/de/sandboxing.md#per-command-allowed-domains-in-auto-mode), und jeder andere Shell-Befehl wird durch ihn geleitet
* **Standard**: `false`

```json settings.json theme={null}
{
  "autoMode": {
    "classifyAllShell": true
  }
}
```

Siehe [Alle Shell-Befehle durch den Klassifikator leiten](https://code.claude.com/docs/de/auto-mode-config.md#route-all-shell-commands-through-the-classifier).

### `disableAutoMode`

Entfernen Sie den [Auto-Modus](https://code.claude.com/docs/de/permission-modes.md#eliminate-prompts-with-auto-mode) aus dem `Shift+Tab`-Zyklus. Jede Sitzung, die sonst [im Auto-Modus starten würde](https://code.claude.com/docs/de/permission-modes.md#which-mode-a-session-starts-in), ob von `--permission-mode auto`, einer Einstellungsdatei oder dem integrierten Standard, startet stattdessen im `default`-Modus. Administratoren setzen es in verwalteten Einstellungen, um zu verhindern, dass Entwickler in ihrer Organisation den Auto-Modus verwenden.

* **Geltungsbereich**: [`Any file`](#scopes). Am nützlichsten in [verwalteten Einstellungen](https://code.claude.com/docs/de/managed-settings.md), wo Benutzer es nicht überschreiben können. Auch unter `permissions` als `permissions.disableAutoMode` akzeptiert.
* **Typ**: die Zeichenfolge `"disable"`
* **Standard**: nicht gesetzt

```json settings.json theme={null}
{
  "disableAutoMode": "disable"
}
```

### `permissions`

Steuern Sie, welche Tools Claude ohne Nachfrage verwenden kann, bei welchen immer nachgefragt wird und welche blockiert sind, und legen Sie den [Berechtigungsmodus](https://code.claude.com/docs/de/permission-modes.md) fest, in dem eine Sitzung startet. Jeder `permissions.*`-Schlüssel unten verschachtelt sich unter diesem Objekt.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Objekt mit `allow`, `ask`, `deny`, `additionalDirectories`, `blockReadsOutsideWorkingDirectories`, `defaultMode`, `disableBypassPermissionsMode` und `disableAutoMode`
* **Standard**: nicht gesetzt

Dieses Beispiel genehmigt `npm run`-Befehle ohne Nachfrage, fragt vor `git push` nach, blockiert Lesevorgänge von `.env` und startet Sitzungen im `acceptEdits`-Modus:

```json settings.json theme={null}
{
  "permissions": {
    "allow": ["Bash(npm run *)"],
    "ask": ["Bash(git push *)"],
    "deny": ["Read(./.env)"],
    "defaultMode": "acceptEdits"
  }
}
```

Die drei Regel-Arrays teilen sich eine Syntax; siehe [Berechtigungsregelsyntax](#permission-rule-syntax) unter `permissions.allow`. Informationen dazu, wie Berechtigungsregeln aus verschiedenen Dateien kombiniert werden, finden Sie unter [Wie Berechtigungsregeln über Geltungsbereiche hinweg zusammengeführt werden](https://code.claude.com/docs/de/permissions.md#settings-precedence); Informationen dazu, wie Einstellungsschlüssel im Allgemeinen kombiniert werden, finden Sie unter [Einstellungspriorität](https://code.claude.com/docs/de/settings.md#settings-precedence) im Einstellungshandbuch.

### `useAutoModeDuringPlan`

Wählen Sie, ob Claude Code den Auto-Modus-Klassifikator verwendet, um Shell-Befehle im Plan-Modus zu überprüfen. Mit dem Standard `true` überprüft der Klassifikator jeden Befehl während der Planung, wenn der Auto-Modus verfügbar ist, und Sie sehen keine Abfrage, außer bei [Entfernungen kritischer Pfade](https://code.claude.com/docs/de/permission-modes.md#critical-paths). Setzen Sie `false`, um für jeden Befehl außerhalb des integrierten Satzes nur lesender Befehle eine Berechtigungsabfrage zu erhalten. Wird in `/config` als **Auto-Modus während Plan verwenden** angezeigt.

* **Geltungsbereich**: [`User, local, or managed`](#scopes). Ein Repository kann es nicht für Sie ausschalten.
* **Typ**: Boolean
  * `true`: dasselbe wie nicht gesetzt; wenn der Auto-Modus verfügbar ist, überprüft der Klassifikator jeden Shell-Befehl während der Planung, anstatt bei Ihnen nachzufragen, außer bei [Entfernungen kritischer Pfade](https://code.claude.com/docs/de/permission-modes.md#critical-paths). Ein `false` in einer dieser Dateien schaltet es immer noch aus
  * `false`: Sie erhalten eine Berechtigungsabfrage für jeden Befehl außerhalb des integrierten Satzes nur lesender Befehle
* **Standard**: `true`

```json settings.json theme={null}
{
  "useAutoModeDuringPlan": false
}
```

### `permissions.allow`

Listen Sie die Tool-Verwendungen auf, die Claude Code ohne Nachfrage genehmigt. In einer MCP-Regel kann `*` nur im Tool-Namen nach dem `mcp__<server>__`-Präfix erscheinen, wie `mcp__github__get_*`; es kann nicht im Server-Namen erscheinen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Array von Berechtigungsregel-Zeichenfolgen
* **Standard**: nicht gesetzt
* **Sitzungsspezifische Überschreibungen**: `--allowedTools` fügt Allow-Regeln für eine Sitzung hinzu, und eine Deny-Regel aus einer Einstellungsdatei blockiert immer noch ein Tool, das sie benennt

Dieses Beispiel genehmigt `git diff` und lässt Claude Code Ihre `.zshrc` ohne Nachfrage lesen:

```json settings.json theme={null}
{
  "permissions": {
    "allow": ["Bash(git diff *)", "Read(~/.zshrc)"]
  }
}
```

Claude Code wendet `allow`-Regeln aus der `.claude/settings.json` eines Projekts nur an, nachdem Sie den [Workspace-Trust-Dialog](https://code.claude.com/docs/de/permissions.md#project-allow-rules-and-workspace-trust) für diesen Ordner akzeptiert haben.

#### Berechtigungsregelsyntax

Berechtigungsregeln folgen dem Format `Tool` oder `Tool(specifier)`. Claude Code wertet `deny`-Regeln zuerst aus, dann `ask`, dann `allow`, und die erste Übereinstimmung entscheidet, unabhängig davon, wie spezifisch jede Regel ist; siehe die [Berechtigungsregel-Evaluierungsreihenfolge](https://code.claude.com/docs/de/permissions.md#manage-permissions).

Jede Zeile zeigt eine Regelform und worauf sie zutrifft.

| Regel | Worauf sie zutrifft |
| :- | :- |
| `Bash` | Jeder Bash-Befehl |
| `Bash(npm run *)` | Befehle, die mit `npm run` beginnen |
| `Read(./.env)` | Lesevorgänge der `.env`-Datei |
| `WebFetch(domain:example.com)` | Fetch-Anfragen an example.com |

Für die vollständige Regelsyntax, einschließlich Wildcard-Verhalten, Tool-spezifischer Muster für Read, Edit, WebFetch, MCP und Agent-Regeln sowie der Sicherheitsbeschränkungen von Bash-Mustern, siehe [Berechtigungsregelsyntax](https://code.claude.com/docs/de/permissions.md#permission-rule-syntax).

### `permissions.ask`

Listen Sie die Tool-Verwendungen auf, bei denen Sie um Bestätigung gebeten werden, auch in einem Berechtigungsmodus, der sie sonst genehmigen würde, wie `acceptEdits` oder `bypassPermissions`. Im `dontAsk`-Modus verweigert Claude Code eine entsprechende Tool-Verwendung, anstatt nachzufragen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Array von Berechtigungsregel-Zeichenfolgen
* **Standard**: nicht gesetzt

```json settings.json theme={null}
{
  "permissions": {
    "ask": ["Bash(git push *)"]
  }
}
```

### `permissions.deny`

Listen Sie die Tool-Verwendungen auf, die Claude Code blockiert. Verwenden Sie es für Dateien, die API-Schlüssel, Geheimnisse oder Umgebungswerte enthalten: Claude Code schließt entsprechende Dateien aus der Dateiermittlung und Suchergebnissen aus, verweigert Lesevorgänge dafür und blockiert die [Edit- und Write-Tools](https://code.claude.com/docs/de/permissions.md#read-and-edit) auf den entsprechenden Pfaden.

Read- und Edit-Deny-Regeln gelten für die integrierten Datei-Tools von Claude, für Dateibefehle, die Claude Code in Bash erkennt, wie `cat`, `head`, `tail`, `sed` und `tee`, und für die Ziele von Bash-[Umleitungen](https://code.claude.com/docs/de/permissions.md#redirections) wie `> file` und `< file`; sie gelten nicht für einen Befehl, der Dateien liest, ohne sie zu benennen, wie `grep -r pattern .`, oder für beliebige Unterprozesse, daher [aktivieren Sie die Sandbox](https://code.claude.com/docs/de/sandboxing.md) für eine Durchsetzung auf Betriebssystemebene.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Array von Berechtigungsregel-Zeichenfolgen
* **Standard**: nicht gesetzt
* **Sitzungsspezifische Überschreibungen**: `--disallowedTools` fügt Deny-Regeln für eine Sitzung neben diesem Schlüssel hinzu

Dieses Beispiel verweigert Lesevorgänge von `.env`-Dateien, dem `secrets`-Verzeichnis und einer Datei mit Anmeldedaten und blockiert `curl`-Befehle:

```json settings.json theme={null}
{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Read(./config/credentials.json)",
      "Bash(curl *)"
    ]
  }
}
```

Tool-Namen akzeptieren Glob-Muster, daher verweigert `"*"` jedes Tool und `"mcp__*"` verweigert jedes MCP-Tool. Claude Code ignoriert eine Deny-Regel für das [`EndConversation`](https://code.claude.com/docs/de/tools-reference#endconversation-tool-behavior)-Tool, solange noch ein anderes Tool für Claude verfügbar ist. Eine `Bash`-Deny-Regel gleicht den Befehl so ab, wie Claude ihn schreibt, daher stoppt `Bash(curl *)` nicht `/usr/bin/curl` oder `sh -c 'curl …'`; siehe [worauf eine Bash-Regel nicht zutrifft](https://code.claude.com/docs/de/permissions.md#bash-rule-limits). Dieser Schlüssel ersetzt die veraltete `ignorePatterns`-Konfiguration.

### `permissions.additionalDirectories`

Geben Sie Claude Dateizugriff auf Verzeichnisse außerhalb desjenigen, in dem Sie gestartet haben, als zusätzliche [Arbeitsverzeichnisse](https://code.claude.com/docs/de/permissions.md#working-directories). Die meisten `.claude/`-Konfigurationen werden aus diesen Verzeichnissen [nicht ermittelt](https://code.claude.com/docs/de/permissions.md#additional-directories-grant-file-access-not-configuration).

* **Geltungsbereich**: [`Any file`](#scopes), mit [Einschränkungen beim Sandbox-Schreibzugriff](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox), den Projekt- und lokale Einträge gewähren
* **Typ**: Array von Verzeichnispfaden
* **Standard**: nicht gesetzt
* **Sitzungsspezifische Überschreibungen**: `--add-dir` und `/add-dir` fügen Verzeichnisse für eine Sitzung neben diesem Schlüssel hinzu

```json settings.json theme={null}
{
  "permissions": {
    "additionalDirectories": ["../docs/"]
  }
}
```

Wie `allow`-Regeln werden Einträge in der `.claude/settings.json` eines Projekts nur wirksam, nachdem Sie den [Workspace-Trust-Dialog](https://code.claude.com/docs/de/permissions.md#project-allow-rules-and-workspace-trust) für diesen Ordner akzeptiert haben.

### `permissions.blockReadsOutsideWorkingDirectories`

Lassen Sie die Datei-Tools von Claude Lesevorgänge außerhalb Ihrer [Arbeitsverzeichnisse](https://code.claude.com/docs/de/permissions.md#working-directories) in jedem Berechtigungsmodus verweigern, einschließlich `bypassPermissions`. Claude Code verweigert `Read`-, `Grep`-, `Glob`- und `LSP`-Aufrufe für diese Pfade und weist Claude an, Sie zu bitten, das Verzeichnis mit `/add-dir` hinzuzufügen. Dateien, die Claude Code selbst benötigt, bleiben lesbar, etwa Ihre Skills, Plugins, Regeln, Agenten, Befehle und die Memory-Datei `CLAUDE.md` unter `~/.claude/`. Erfordert Claude Code v2.1.257 oder später.

Shell-Befehle verweigert Claude Code nicht auf dieselbe Weise:

* [Aktionen, die kein Modus automatisch genehmigt](https://code.claude.com/docs/de/permission-modes.md#actions-no-mode-auto-approves) beschreibt, wann ein Shell-Befehl, der einen solchen Pfad liest, bei Ihnen nachfragt
* [In einer Sandbox ausgeführte Befehle unter der Blockierung](#sandboxed-commands-under-the-block) beschreibt, was ein in einer Sandbox ausgeführter Befehl lesen kann

Ein Bash-Befehl, den der Shell-Parser nicht nachverfolgen kann, etwa einer, der das Verzeichnis mehr als einmal wechselt oder eine Subshell ausführt, fragt auch im Auto-Modus und im `bypassPermissions`-Modus bei Ihnen nach. Die Abfrage erscheint auch dann, wenn der Befehl keinen Pfad außerhalb der Arbeitsverzeichnisse benennt. Diese Abfrage entfällt, wenn der Befehl in der [Sandbox](https://code.claude.com/docs/de/sandboxing.md) ausgeführt wird und die Sandbox die Blockierung durchsetzt.

Claude Code schreibt hier außerdem `true`, wenn Sie in der [Abfrage des Auto-Modus vor dem ersten Lesevorgang außerhalb der Arbeitsverzeichnisse](https://code.claude.com/docs/de/permission-modes.md#first-read-outside-the-working-directories) festlegen, solche Lesevorgänge zu blockieren.

* **Geltungsbereich**: [`Any file`](#scopes). Ein `true` in einer beliebigen Datei gilt, daher kann ein Repository die Blockierung für sich selbst aktivieren, Ihre Blockierung aber nicht aufheben.
* **Typ**: Boolean
  * `true`: Die Datei-Tools von Claude verweigern Lesevorgänge außerhalb der Arbeitsverzeichnisse
  * `false`: dasselbe wie nicht gesetzt; die Blockierung gilt trotzdem, wenn eine andere Datei `true` setzt
* **Standard**: nicht gesetzt, daher folgen Lesevorgänge außerhalb der Arbeitsverzeichnisse Ihrem [Berechtigungsmodus](https://code.claude.com/docs/de/permission-modes.md)

```json settings.json theme={null}
{
  "permissions": {
    "blockReadsOutsideWorkingDirectories": true
  }
}
```

Verzeichnisse, die Sie mit `--add-dir`, `/add-dir` oder `additionalDirectories` in Ihren Benutzer- oder verwalteten Einstellungen hinzufügen, zählen für die Blockierung als Arbeitsverzeichnisse. Verzeichnisse, die nur in Repository-Einstellungen hinzugefügt werden, zählen nicht: solche in `.claude/settings.json` und solche in `.claude/settings.local.json`, sofern Git diese Datei nicht als nicht verfolgt meldet. In einem Verzeichnis, das kein Git-Repository ist, oder wenn Git die Datei verfolgt, behandelt Claude Code `.claude/settings.local.json` als Repository-Einstellungen; legen Sie Verzeichnisse, die lesbar bleiben sollen, daher stattdessen in Ihren Benutzereinstellungen fest.

Wenn [`autoMemoryDirectory`](#automemorydirectory) aus der `.claude/settings.json` des Projekts kommt oder aus einer `.claude/settings.local.json`, die [als vom Repository bereitgestellt behandelt wird](https://code.claude.com/docs/de/permissions.md#when-your-local-settings-file-needs-trust), lädt Claude Code kein [Auto-Memory](https://code.claude.com/docs/de/memory.md#storage-location) aus diesem Verzeichnis und speichert keines darin.

Um die Blockierung aufzuheben, entfernen Sie den Schlüssel aus jeder Einstellungsdatei, die ihn setzt, und starten Sie dann eine neue Sitzung.

#### In einer Sandbox ausgeführte Befehle unter der Blockierung

Wenn [Sandboxing](https://code.claude.com/docs/de/sandboxing.md) aktiviert ist, umfasst die Blockierung auch in einer Sandbox ausgeführte Befehle. Claude Code verweigert ihnen den Lesezugriff auf Ihr Home-Verzeichnis und auf die anderen Stammverzeichnisse, die Benutzerdateien enthalten: `/Users`, `/home`, `/root`, `/Volumes`, `/mnt`, `/media`, `/run/media` und `/srv`. Anschließend gibt es die Arbeitsverzeichnisse, die [Worktrees](https://code.claude.com/docs/de/worktrees.md), die Claude Code in der Sitzung erstellt, das temporäre Verzeichnis der Sitzung und die Teile von `~/.claude`, die Befehle benötigen, etwa Skills und Plugins, wieder frei. Solange die Blockierung gilt, zählen `allowRead`- und `allowWrite`-Einträge aus Repository-Einstellungen nicht.

Wenn das Arbeitsverzeichnis der Sitzung ein verknüpfter [Git-Worktree](https://code.claude.com/docs/de/worktrees.md) ist, einschließlich eines, den Claude Code während der Sitzung betreten hat, bleibt das gemeinsame `.git`-Verzeichnis des Repositorys für in einer Sandbox ausgeführte Befehle lesbar und beschreibbar, sodass Git dort weiterhin funktioniert.

In diesen Fällen erreicht die Blockierung in einer Sandbox ausgeführte Befehle nicht, während die Datei-Tools von Claude sie weiterhin durchsetzen:

* Die Dateisystemisolierung ist über [`sandbox.filesystem.disabled`](#sandbox-filesystem-disabled) deaktiviert
* [`allowManagedReadPathsOnly`](#sandbox-filesystem-allowmanagedreadpathsonly) ist gesetzt
* Der Pfad des Verzeichnisses, in dem Sie Claude Code gestartet haben, enthält ein Glob-Zeichen wie `*`, `?` oder `[`

Unter der Blockierung gibt Claude Code Ihre globalen Git-Konfigurationsdateien für in einer Sandbox ausgeführte Befehle wieder frei, damit `git` Ihre Identität und Einstellungen beibehält:

* `~/.gitconfig`
* Die Dateien `config`, `ignore` und `attributes` unter `$XDG_CONFIG_HOME/git`, standardmäßig `~/.config/git`
* Dateien, die Ihre globale Git-Konfiguration über `[include]`, `[includeIf]`, `core.excludesFile` oder `core.attributesFile` angibt

Claude Code beurteilt jede Datei einzeln. Wenn eine Datei an einem Ort liegt, an dem ein in einer Sandbox ausgeführter Befehl schreiben kann, direkt oder über einen Symlink, gibt Claude Code die darin angegebenen Dateien nicht wieder frei.

Unter Linux und WSL2 kann eine Konfigurationsdatei, die ein Symlink ist, unter ihrem eigenen Pfad unlesbar bleiben; `git` läuft dann ohne sie. `~/.git-credentials` und `$XDG_CONFIG_HOME/git/credentials` bleiben blockiert.

Wenn eine wieder freigegebene Datei ein Geheimnis enthält, etwa ein `http.extraHeader`-Token, fügen Sie ihren Pfad zu [`sandbox.filesystem.denyRead`](#sandbox-filesystem-denyread) hinzu. Ein `denyRead`-Eintrag, der eine Datei abdeckt, hat immer Vorrang vor dieser Freigabe.

### `permissions.defaultMode`

Legen Sie den [Berechtigungsmodus](https://code.claude.com/docs/de/permission-modes.md) fest, in dem neue Sitzungen starten. Wenn Sie ihn nicht gesetzt lassen, starten Sitzungen im [integrierten Standard](https://code.claude.com/docs/de/permission-modes.md#which-mode-a-session-starts-in) für Ihre Oberfläche.

* **Geltungsbereich**: [`Any file`](#scopes). `auto` und `bypassPermissions` werden nicht aus Projekt- oder lokalen Einstellungen wirksam, daher setzen Sie sie stattdessen in `~/.claude/settings.json`. Vor v2.1.257 wurde `bypassPermissions` aus jeder Datei wirksam. Für Konversationen, die die VS Code-Erweiterung startet, liest Claude Code nur Benutzer-, verwaltete und `--settings`-Werte.
* **Typ**: Zeichenfolge, eine von:
  * `"default"`: Claude Code führt nur Lesevorgänge ohne Nachfrage aus
  * `"acceptEdits"`: Claude Code führt auch Dateibearbeitungen und häufige Dateisystem-Befehle wie `mkdir` und `mv` ohne Nachfrage aus
  * `"plan"`: Claude Code liest und plant, blockiert aber Bearbeitungen, bis Sie einen Plan genehmigen
  * `"auto"`: Claude Code läuft ohne die üblichen Nachfragen; bevor Aktionen wie Shell-Befehle und Netzwerkanfragen ausgeführt werden, prüft ein Klassifikator im Hintergrund, ob sie mit Ihrer Anfrage übereinstimmen
  * `"dontAsk"`: Claude Code verweigert automatisch jeden Aufruf, bei dem sonst nachgefragt würde, wobei ein von Ihnen installierter [Mod](https://code.claude.com/docs/de/plugins/mods/overview.md) [einige dieser Aufrufe](https://code.claude.com/docs/de/permissions.md#precedence-among-rules-hooks-and-mods) dennoch genehmigen kann. Dateilesevorgänge innerhalb Ihrer Arbeitsverzeichnisse, andere Aktionen, die keine Genehmigung benötigen, und vorab genehmigte Tools werden weiterhin ausgeführt, mit Ausnahme von Lesevorgängen aus [Netzwerkpfaden](https://code.claude.com/docs/de/permissions.md#network-paths)
  * `"bypassPermissions"`: Claude Code führt alles ohne Nachfrage aus
  * `"manual"`: ein Alias für `"default"`
* **Standard**: nicht gesetzt
* **Sitzungsspezifische Überschreibungen**: `--permission-mode` und sein Äquivalent `--dangerously-skip-permissions` für `bypassPermissions` haben Vorrang vor diesem Schlüssel für eine Sitzung

```json settings.json theme={null}
{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}
```

Berechtigungsregeln überlagern jeden Modus: `deny`-Regeln blockieren in jedem Modus, einschließlich `bypassPermissions`. Siehe [Berechtigungsmodi](https://code.claude.com/docs/de/permission-modes.md). In Cloud-Sitzungen berücksichtigt Claude Code nur `acceptEdits`, `plan`, `default` und `auto` aus diesem Schlüssel. Für Konversationen, die die VS Code-Erweiterung startet, siehe [welche Einstellung die Erweiterung für den Start-Berechtigungsmodus liest](https://code.claude.com/docs/de/permission-modes.md#switch-permission-modes).

### `permissions.disableBypassPermissionsMode`

Verhindern Sie, dass jemand den `bypassPermissions`-Modus betritt. Claude Code lehnt dann das `--dangerously-skip-permissions`-Flag ab und ignoriert die Angabe `permissionMode: bypassPermissions` in einer [Agent-Definition](https://code.claude.com/docs/de/sub-agents.md#permission-modes), daher wird der Subagent mit dem Berechtigungsmodus der übergeordneten Sitzung ausgeführt.

* **Geltungsbereich**: [`Any file`](#scopes). Typischerweise in [verwalteten Einstellungen](https://code.claude.com/docs/de/managed-settings.md) gesetzt, um Organisationsrichtlinien durchzusetzen.
* **Typ**: die Zeichenfolge `"disable"`
* **Standard**: nicht gesetzt
* **Sitzungsspezifische Überschreibungen**: Dieser Schlüssel hat Vorrang vor `--dangerously-skip-permissions`, das Claude Code ablehnt, während der Schlüssel gesetzt ist

```json settings.json theme={null}
{
  "permissions": {
    "disableBypassPermissionsMode": "disable"
  }
}
```

Vor v2.1.223 wendete Claude Code den Frontmatter-Berechtigungsmodus auch mit deaktiviertem Bypass an.

### `skipAutoPermissionPrompt`

Überspringen Sie die einmalige Mitteilung, die den [Auto-Modus](https://code.claude.com/docs/de/permission-modes.md#eliminate-prompts-with-auto-mode) beschreibt und die Claude Code anzeigt, wenn Sie selbst zum ersten Mal den Auto-Modus betreten, beispielsweise durch Ihre eigenen Einstellungen oder den Modus-Selektor, anstatt wenn der integrierte Standard eine Sitzung darin startet. Claude Code zeigt diese Mitteilung einmal an und zeichnet dann auf, dass sie angezeigt wurde, daher ist dieser Schlüssel nur relevant, wenn die Mitteilung noch nicht angezeigt wurde.

* **Geltungsbereich**: [`User or managed`](#scopes). Ein Repository kann es nicht für Sie setzen.
* **Typ**: Boolean
  * `true`: Claude Code überspringt die Mitteilung
  * `false`: dasselbe wie nicht gesetzt; die Mitteilung wird einmal angezeigt, es sei denn, eine andere dieser Dateien setzt `true`
* **Standard**: nicht gesetzt, daher wird die Mitteilung einmal angezeigt

```json settings.json theme={null}
{
  "skipAutoPermissionPrompt": true
}
```

### `skipDangerousModePermissionPrompt`

Überspringen Sie den Bestätigungsdialog, den Claude Code anzeigt, bevor eine Sitzung den `bypassPermissions`-Modus betritt, ob von `--dangerously-skip-permissions` oder von `defaultMode: "bypassPermissions"`. Claude Code schreibt hier `true` in Ihre Benutzereinstellungen, wenn Sie diesen Dialog einmal akzeptieren.

* **Geltungsbereich**: [`User, local, or managed`](#scopes). Ein nicht vertrauenswürdiges Repository kann den Dialog nicht für Sie überspringen.
* **Typ**: Boolean
  * `true`: Claude Code überspringt den Bestätigungsdialog, bevor eine Sitzung den `bypassPermissions`-Modus betritt
  * `false`: dasselbe wie nicht gesetzt; der Dialog wird angezeigt, es sei denn, eine andere dieser Dateien setzt `true`
* **Standard**: nicht gesetzt, daher wird der Dialog angezeigt

```json settings.json theme={null}
{
  "skipDangerousModePermissionPrompt": true
}
```

## Sandbox-Einstellungen

Isolieren Sie die Befehle, die Claude ausführt, von Ihrem Dateisystem, Ihrem Netzwerk und Ihren Anmeldedaten. Informationen zur Funktionsweise von Sandboxing und zu Plattformanforderungen finden Sie unter [Sandboxing](https://code.claude.com/docs/de/sandboxing.md).

### `sandbox`

Isolieren Sie die Bash-Befehle, die Claude ausführt, mit [Sandboxing](https://code.claude.com/docs/de/sandboxing.md) von Ihrem Dateisystem und Netzwerk. Aktivieren Sie die Sandbox mit `enabled`, und grenzen Sie dann mit den Unterobjekten `filesystem`, `network` und `credentials` ein oder erweitern Sie, worauf in der Sandbox ausgeführte Befehle zugreifen können. Die Sandbox läuft auf macOS, Linux und WSL2.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Objekt mit `enabled`, `failIfUnavailable`, `autoAllowBashIfSandboxed`, `excludedCommands`, `allowUnsandboxedCommands`, `enableWeakerNestedSandbox`, `enableWeakerNetworkIsolation`, `allowAppleEvents`, `allowNestedUserNamespaces`, `bwrapPath`, `socatPath`, `ignoreViolations` und `ripgrep` sowie den Objekten `filesystem`, `network` und `credentials`
* **Standard**: nicht gesetzt, daher führt Claude Code Befehle ohne Sandbox aus

Dies aktiviert die Sandbox, überspringt Berechtigungsabfragen für Befehle in der Sandbox, führt `docker` außerhalb der Sandbox aus, öffnet zwei zusätzliche Schreibpfade, verbirgt Ihre AWS-Anmeldedatei und erlaubt GitHub und npm vorab:

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["docker *"],
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}
```

Wenn verwaltete Einstellungen einen booleschen Schlüssel wie `enabled` oder `failIfUnavailable` setzen, überschreibt dieser Wert alles, was ein Entwickler setzt. Claude Code führt Array-Schlüssel über die Einstellungsbereiche zusammen, die die Sitzung lädt, sodass ein Entwickler Einträge anhängen kann; siehe [Keep developers from widening the policy](https://code.claude.com/docs/de/sandboxing.md#keep-developers-from-widening-the-policy) für die Sperren, die nur in verwalteten Einstellungen gelten. Um Sandboxing für eine Organisation zu erzwingen, siehe [Enforce sandboxing with managed settings](https://code.claude.com/docs/de/sandboxing.md#enforce-sandboxing-with-managed-settings).

### `sandbox.enabled`

Aktivieren Sie [Sandboxing](https://code.claude.com/docs/de/sandboxing.md) für Bash-Befehle. Wenn Sie einen Modus im `/sandbox`-Panel auswählen, schreibt Claude Code diesen Schlüssel in `.claude/settings.local.json` für das aktuelle Projekt; setzen Sie ihn in `~/.claude/settings.json`, um jedes Projekt in einer Sandbox auszuführen.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Boolescher Wert
  * `true`: Claude Code führt Bash-Befehle in der Sandbox aus
  * `false`: Bash-Befehle werden ohne Sandbox ausgeführt
* **Standard**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true
  }
}
```

Auf Linux und WSL2 benötigt die Sandbox `bubblewrap` und `socat`; siehe [Set up Linux and WSL2](https://code.claude.com/docs/de/sandboxing.md#set-up-linux-and-wsl2). Wenn die Sandbox nicht starten kann, führt Claude Code Befehle ohne Sandbox aus, es sei denn, Sie setzen auch [`failIfUnavailable`](#sandbox-failifunavailable).

### `sandbox.failIfUnavailable`

Lassen Sie Claude Code beim Start mit einem Fehler beenden, wenn `sandbox.enabled` `true` ist, die Sandbox aber nicht starten kann, weil eine Abhängigkeit fehlt oder die Plattform nicht unterstützt wird. Ohne diesen Schlüssel führt Claude Code Befehle ohne Sandbox aus. Verwaltete Bereitstellungen, die Sandboxing als Sicherheitsschranke erfordern, können diese Einstellung verwenden.

Auf einer Plattform, die die Sandbox nicht unterstützt, startet Claude Code nicht, wenn dieser Schlüssel aktiviert ist. Siehe [Enforce sandboxing with managed settings](https://code.claude.com/docs/de/sandboxing.md#enforce-sandboxing-with-managed-settings).

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Boolean
  * `true`: Claude Code beendet sich beim Start mit einem Fehler, wenn `sandbox.enabled` auf `true` steht, die Sandbox aber nicht starten kann. Besteht die Sandbox diese Prüfung und schlägt danach die Initialisierung fehl, läuft die Sitzung weiter und Claude Code [verweigert jeden Befehl in der Sandbox](https://code.claude.com/docs/de/sandboxing.md#commands-refused-with-sandbox-is-required)
  * `false`: Claude Code führt Befehle ohne Sandbox aus, wenn die Sandbox nicht starten kann
* **Standard**: `false`

Dieses Beispiel schaltet die Sandbox für verwaltete Rechner ein und setzt `failIfUnavailable` auf `true`:

```json managed-settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "failIfUnavailable": true
  }
}
```

Siehe [Enforce sandboxing with managed settings](https://code.claude.com/docs/de/sandboxing.md#enforce-sandboxing-with-managed-settings).

### `sandbox.autoAllowBashIfSandboxed`

Lassen Sie Claude Code Bash-Befehle in der Sandbox ohne Berechtigungsabfrage ausführen. Befehle, die nicht in der Sandbox ausgeführt werden können, durchlaufen weiterhin den regulären Berechtigungsfluss, und `deny`-Regeln sowie inhaltsbezogene `ask`-Regeln wie `Bash(git push *)` gelten weiterhin; eine bloße `Bash`-ask-Regel wird für Befehle in der Sandbox übersprungen. Setzen Sie den Schlüssel auf `false`, um auch Befehle in der Sandbox durch den regulären Berechtigungsfluss zu leiten, den die **Mode**-Registerkarte von `/sandbox` als regulären Berechtigungsmodus bezeichnet.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Boolescher Wert
  * `true`: Claude Code führt Bash-Befehle in der Sandbox ohne Berechtigungsabfrage aus, außer in den Fällen, die [Auto-allow mode](https://code.claude.com/docs/de/sandboxing.md#auto-allow-mode) beschreibt; `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` deaktiviert die automatische Freigabe
  * `false`: Befehle in der Sandbox durchlaufen den regulären Berechtigungsfluss, daher entscheiden Ihre allow-Regeln und Ihr Berechtigungsmodus. Die **Mode**-Registerkarte von `/sandbox` nennt dies regulären Berechtigungsmodus
* **Standard**: `true`

Dies behält die Sandbox bei und leitet Befehle in der Sandbox durch den regulären Berechtigungsfluss:

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": false
  }
}
```

Siehe [Auto-allow mode](https://code.claude.com/docs/de/sandboxing.md#auto-allow-mode) dafür, wobei der Modus mit automatischer Freigabe weiterhin nachfragt und wie er sich im Plan-Modus verhält.

### `sandbox.excludedCommands`

Benennen Sie Befehle, die Claude Code außerhalb der Sandbox ausführt, z. B. Tools, die darin nicht funktionieren. Jeder Eintrag verwendet die gleiche Syntax wie der Inhalt einer `Bash(...)`-[Berechtigungsregel](https://code.claude.com/docs/de/permissions.md#permission-rule-syntax): ein exakter Befehl, ein Präfix wie `docker *` oder ein Wildcard-Muster. Ein Muster ohne Wildcard ist eine exakte Übereinstimmung, daher passt `docker` nur auf `docker` ohne Argumente.

Ihre Einträge nehmen einen Bash-Aufruf nur dann aus der Sandbox heraus, wenn sie jeden Befehl darin abdecken, und einige Aufrufformen bleiben selbst dann in der Sandbox. Ein `docker *`-Eintrag allein nimmt `npm ci && docker build .` nicht aus der Sandbox heraus.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Array von Befehlsmustern
* **Standard**: nicht gesetzt, daher wird kein Befehl ausgeschlossen

```json settings.json theme={null}
{
  "sandbox": {
    "excludedCommands": ["docker *"]
  }
}
```

Claude Code hält einen Bash-Aufruf in der Sandbox, wenn er unter anderem eine dieser Formen hat:

* Ein Befehl, der mit `sudo`, `eval` oder `xargs` beginnt
* Ein `cd`, `pushd` oder `popd`, egal wo es im Aufruf erscheint
* Eine Befehlsersetzung, eine Subshell oder ein Kontrollfluss-Block wie `if` oder `for`
* Eine Umleitung, wie `docker build . > build.log`, außer einer, die nur einen Dateideskriptor dupliziert, wie `2>&1` es tut
* Ein Befehlsname, der aus einer Variable stammt
* Ein `git clone`, `git init`, `git worktree add`, `git worktree move` oder `git bundle create` mit einem Pfadargument, das absolut ist, mit `~` beginnt oder ein `..`-Segment enthält

Zum Beispiel bleibt `cd build && docker compose up` unter einem `docker *`-Eintrag in der Sandbox, und das Hinzufügen eines `cd`-Eintrags ändert das nicht. Unter einem `git *`-Eintrag wird `git clone <url> vendor/lib` außerhalb der Sandbox ausgeführt, aber `git clone <url> ~/tools` bleibt in der Sandbox. Ein Clone schreibt einen ganzen Baum von Dateien, möglicherweise auch ausführbare, an die Stelle, auf die sein Zielpfad zeigt.

Ausgeschlossene Befehle durchlaufen weiterhin den regulären Berechtigungsfluss. Ausschluss ist eine Bequemlichkeit, keine Sicherheitsgrenze: Wenn ein Tool nur an eine bestimmte Stelle schreiben muss, hält [`filesystem.allowWrite`](#sandbox-filesystem-allowwrite) es in der Sandbox.

Einträge aus den Einstellungsbereichen, die die Sitzung lädt, werden zu einer Liste zusammengeführt, es sei denn, die Sandbox ist [vom Admin vorgeschrieben](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox). Solange dies der Fall ist, ignoriert Claude Code Einträge in `.claude/settings.json` und `.claude/settings.local.json`, sodass ein geklontes Repository keine Befehle aus der Sandbox herausnehmen kann. Einträge in verwalteten Einstellungen, `--settings` und Ihrer `~/.claude/settings.json` gelten weiterhin, und für diese Liste gibt es keine Sperre, die nur in verwalteten Einstellungen gilt.

### `sandbox.allowUnsandboxedCommands`

Lassen Sie Claude einen Befehl mit dem Parameter `dangerouslyDisableSandbox` außerhalb der Sandbox erneut versuchen, nachdem die Sandbox ihn blockiert hat. Bei `false` ignoriert Claude Code diesen Parameter. Solange die Sandbox läuft, werden Befehle, die Claude ausführt, dann in der Sandbox ausgeführt, es sei denn, sie entsprechen einem [`excludedCommands`](#sandbox-excludedcommands)-Eintrag. Die **Overrides**-Registerkarte von `/sandbox` zeigt diesen Zustand als **Strict sandbox mode** an. Ein `false` in verwalteten Einstellungen aktiviert den strikten Sandbox-Modus für die Entwickler, für die diese Einstellungen gelten.

* **Bereich**: [`Any file`](#scopes), mit [einer Einschränkung für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#turn-off-the-retry-with-strict-sandbox-mode)
* **Typ**: Boolescher Wert
  * `true`: Claude kann einen Befehl mit dem Parameter `dangerouslyDisableSandbox` außerhalb der Sandbox erneut versuchen, nachdem die Sandbox ihn blockiert hat
  * `false`: Claude Code ignoriert diesen Parameter, daher werden Befehle, die Claude ausführt, solange die Sandbox läuft, in der Sandbox ausgeführt, es sei denn, sie entsprechen einem `excludedCommands`-Eintrag
* **Standard**: `true`

Dies erzwingt den strikten Sandbox-Modus für alle, für die die verwalteten Einstellungen gelten:

```json managed-settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "allowUnsandboxedCommands": false
  }
}
```

Ein `false` aus verwalteten Einstellungen oder `--settings` macht die Sandbox außerdem [vom Admin vorgeschrieben](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox). Ein `false` in Ihren Benutzereinstellungen setzt sich gegen ein `true` eines Projekts durch, macht die Sandbox aber nicht vom Admin vorgeschrieben. Das Durchsetzen gegen den Wert eines Projekts erfordert Claude Code v2.1.285 oder später.

Wer einen Wiederholungsversuch ohne Sandbox genehmigt, hängt von Ihrem Berechtigungsmodus und Ihren allow-Regeln ab. Siehe [The unsandboxed retry escape hatch](https://code.claude.com/docs/de/sandboxing.md#the-unsandboxed-retry-escape-hatch).

Um zu sehen, wann Befehle, die Sie selbst an der [`!`-Shell-Modus-Eingabeaufforderung](https://code.claude.com/docs/de/interactive-mode#shell-mode-with-prefix) eingeben, in der Sandbox ausgeführt werden, siehe [strict sandbox mode](https://code.claude.com/docs/de/sandboxing.md#turn-off-the-retry-with-strict-sandbox-mode).

### `sandbox.filesystem`

Legen Sie fest, welche Pfade Befehle in der Sandbox lesen und schreiben können. Standardmäßig können sie in das Arbeitsverzeichnis, das benutzerspezifische Temp-Verzeichnis und Verzeichnisse schreiben, die Sie mit `--add-dir`, `/add-dir` oder `permissions.additionalDirectories` hinzufügen, und können den Rest des Dateisystems lesen, einschließlich Anmeldedateien. Erweitern oder verengen Sie dies mit den vier Pfadlisten, oder schalten Sie die Dateisystem-Schicht mit `disabled` aus. Siehe [Filesystem isolation](https://code.claude.com/docs/de/sandboxing.md#filesystem-isolation) für die Standardgrenzen.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Objekt mit den Arrays `allowWrite`, `denyWrite`, `denyRead` und `allowRead`, plus die booleschen Werte `allowManagedReadPathsOnly` und `disabled`
* **Standard**: nicht gesetzt, daher gelten die Standard-Lese- und Schreibgrenzen

Dies lässt Befehle in der Sandbox in ein Build-Verzeichnis und Ihre kubeconfig schreiben und verbirgt Ihre AWS-Anmeldedatei:

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    }
  }
}
```

Claude Code erzwingt diese Listen an der OS-Sandbox-Grenze, daher gelten sie für jeden Unterprozess, den ein Befehl in der Sandbox startet, z. B. `kubectl`, `terraform` oder `npm`. Claude Code fügt Ihre [Berechtigungsregeln](https://code.claude.com/docs/de/sandboxing.md#permission-rules) zu denselben Listen hinzu: `Edit`-allow- und -deny-Regeln zu `allowWrite` und `denyWrite`, `Read`-deny-Regeln zu `denyRead` und `WebFetch(domain:...)`-allow- und -deny-Regeln zu den [`network`](#sandbox-network)-Domänenlisten.

Sofern keine Sperre greift, führt Claude Code diese Listen über die Einstellungsdateien zusammen, die die Sitzung lädt. [`allowManagedReadPathsOnly`](#sandbox-filesystem-allowmanagedreadpathsonly) beschränkt `allowRead` auf Einträge aus verwalteten Einstellungen, und [`allowManagedDomainsOnly`](#sandbox-network-allowmanageddomainsonly) macht dasselbe für zulässige Domänen. [Repository-Sperren](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox) lassen Einträge aus den Einstellungsdateien eines Repositorys weg.

[Configure sandboxing](https://code.claude.com/docs/de/sandboxing.md#configure-sandboxing) behandelt Quellen, die Sie mit `--setting-sources` ausschließen. Wenn Sie eine Liste während einer Sitzung bearbeiten, [wendet Claude Code die Änderung auf die laufende Sitzung an](https://code.claude.com/docs/de/settings.md#when-edits-take-effect).

#### Sandbox-Pfadpräfixe

Pfade in `allowWrite`, `denyWrite`, `denyRead`, `allowRead` und [`credentials.files`](#sandbox-credentials-files) werden nach ihrem Präfix aufgelöst:

| Präfix | Bedeutung | Beispiel |
| :- | :- | :- |
| `/` | Absoluter Pfad vom Dateisystem-Root | `/tmp/build` bleibt `/tmp/build` |
| `~/` | Relativ zum Home-Verzeichnis | `~/.kube` wird zu `$HOME/.kube` |
| `./` oder kein Präfix | Relativ zum Projekt-Root für Projekteinstellungen oder zu `~/.claude` für Benutzereinstellungen | `./output` in `.claude/settings.json` wird zu `<project-root>/output` |

Das Präfix `//path` für absolute Pfade funktioniert ebenfalls. Wenn Sie `/path` mit einem einzelnen Schrägstrich verwenden und eine projektrelative Auflösung erwarten, wechseln Sie zu `./path`. Diese Syntax unterscheidet sich von [Read and Edit permission rules](https://code.claude.com/docs/de/permissions.md#read-and-edit), die `//path` für absolute und `/path` für projektrelative Pfade verwenden: Sandbox-Dateisystempfade folgen den Standardkonventionen, daher ist `/tmp/build` ein absoluter Pfad.

Claude Code entfernt einen nachgestellten Schrägstrich aus einem Verzeichnispfad, daher entsprechen `~/.aws` und `~/.aws/` demselben Verzeichnis. Vor v2.1.224 gab Claude Code den nachgestellten Schrägstrich an die Sandbox weiter, und Claude konnte weiterhin Pfade unter einem `denyRead`- oder `denyWrite`-Eintrag lesen oder schreiben, der mit einem solchen Schrägstrich geschrieben war.

##### Wo Platzhalter in Sandbox-Pfaden funktionieren

Die Platzhalter `*`, `?` und `**` funktionieren unter macOS in allen vier `sandbox.filesystem`-Pfadlisten und unter Linux und WSL2 an weniger Stellen:

| `sandbox.filesystem`-Liste | Was unter Linux und WSL2 funktioniert | Beispiel, das unter Linux und WSL2 nicht funktioniert | Was Sie stattdessen schreiben |
| :- | :- | :- | :- |
| `denyRead`, `allowRead` | Ein abschließendes `/**` funktioniert, sodass `~/build/**` dasselbe Verzeichnis abdeckt wie `~/build`. Jeder andere Platzhalter funktioniert nur nach dem ersten Verzeichnisnamen des [vollständigen Pfads](#sandbox-path-prefixes) des Eintrags. | `/**/*.pem` in `denyRead` deckt nichts ab und blockiert daher keine Lesezugriffe | `/srv/**/*.pem`, mit einem Eintrag für jedes Verzeichnis der obersten Ebene |
| `allowWrite`, `denyWrite` | Nur ein abschließendes `/**` funktioniert, sodass `~/build/**` dasselbe Verzeichnis abdeckt wie `~/build` | `./src/*` deckt nur eine Datei oder ein Verzeichnis in `src` ab, das selbst `*` heißt, und nichts, wenn es keines gibt | `./src`, das alles unter `src` abdeckt, oder ein Eintrag für jeden Pfad |

In `~/keys/*.pem` steht der Platzhalter nach dem ersten Verzeichnisnamen, der bei einem Home-Verzeichnis `/home/alice` `home` lautet:

```text theme={null}
~/keys/*.pem              the entry
/home/alice/keys/*.pem    its full path
 ^^^^                     the first directory name, home
```

Unter Linux und WSL2 warnt der Tab **Config** von `/sandbox` in einer Sitzung vor `Edit`-Berechtigungsregeln, die einen anderen Platzhalter als ein abschließendes `/**` enthalten. Diese Platzhalter funktionieren für in der Sandbox ausgeführte Befehle nicht. Fügen Sie jeden Pfad, den die Regel abdecken soll, oder das Verzeichnis, das sie enthält, bei einer allow-Regel zu `allowWrite` oder bei einer deny-Regel zu `denyWrite` hinzu.

##### Verzeichnisnamen mit eckigen, geschweiften oder runden Klammern

Um ein Verzeichnis zu erlauben oder zu blockieren, dessen Name eckige Klammern enthält, schreiben Sie den Namen so, wie er ist, etwa `./app/[slug]`. In diesem Eintrag ist `[slug]` der tatsächliche Name des Verzeichnisses, einschließlich der Klammern:

```text theme={null}
app/
└── [slug]/
    └── page.tsx
```

Dieser Eintrag deckt alles unter dem Verzeichnis ab, lassen Sie also ein abschließendes `/**` weg. Unter macOS sowie unter Linux und WSL2 muss das Verzeichnis `app/[slug]` existieren, wenn der in der Sandbox ausgeführte Befehl startet.

* **Eckige Klammern wie `[slug]`**: In jeder Liste unter macOS sowie in `denyRead` und `allowRead` unter Linux und WSL2 sind die Klammern in `./app/[slug]` zugleich ein Muster. Der Eintrag passt dann auch auf jeden Pfad unter `app`, der aus einem Zeichen aus `slug` besteht, etwa `app/s` oder `app/g`. Steht dieser Eintrag in `allowRead` oder unter macOS in `allowWrite`, können in der Sandbox ausgeführte Befehle auch diese Pfade erreichen. Benennen Sie alle um, die sie nicht erreichen sollen.
* **Eckige Klammern wie `[user-id]` oder `[post-id]`, bei denen das Zeichen links vom Bindestrich nach dem rechten einsortiert wird**: `./app/[user-id]` deckt nur das Verzeichnis mit genau diesem Namen ab, in jeder Liste auf jeder Plattform. Vor v2.1.304 konnten in der Sandbox ausgeführte Befehle unter Linux und WSL2 nicht starten, solange `denyRead` oder `allowRead` einen solchen Eintrag enthielt.
* **Geschweifte und runde Klammern**: Diese sind gewöhnliche Zeichen, sodass `~/data/{keys,tokens}` ein Verzeichnis namens `{keys,tokens}` abdeckt, nicht zwei Alternativen. Um `~/data/keys` und `~/data/tokens` abzudecken, fügen Sie jedes als eigenen Eintrag hinzu.

### `sandbox.filesystem.allowWrite`

Fügen Sie Pfade hinzu, in die Befehle in der Sandbox schreiben können, über das Arbeitsverzeichnis, das benutzerspezifische Temp-Verzeichnis und die Verzeichnisse hinaus, die Sie mit `--add-dir`, `/add-dir` oder `permissions.additionalDirectories` hinzugefügt haben. Verwenden Sie es, wenn ein Unterprozess wie `kubectl` oder ein Build-Tool außerhalb des Projekts schreiben muss.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Array von Pfadzeichenfolgen, unter Verwendung der [Sandbox-Pfadpräfixe](#sandbox-path-prefixes)
* **Standard**: nicht gesetzt, daher können Befehle in der Sandbox in das Arbeitsverzeichnis, das benutzerspezifische Temp-Verzeichnis, Verzeichnisse, die Sie mit `--add-dir` oder `/add-dir` hinzugefügt haben, und Verzeichnisse in [`permissions.additionalDirectories`](#permissions-additionaldirectories) schreiben

Dies lässt einen Build unter `/tmp/build` schreiben und lässt `kubectl` Ihre kubeconfig aktualisieren:

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"]
    }
  }
}
```

Claude Code führt `allowWrite`-Einträge und die Pfade aus Ihren `Edit(...)`-allow-Berechtigungsregeln über die Einstellungsbereiche zusammen, die die Sitzung lädt, und lässt dabei die aus Repository-Einstellungen weg, solange [`permissions.blockReadsOutsideWorkingDirectories`](#sandboxed-commands-under-the-block) aktiviert ist. [Repository-Sperren](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox) können die Einträge eines Repositorys ebenfalls weglassen. Ein `allowWrite`-Eintrag kann einen [geschützten Pfad](https://code.claude.com/docs/de/sandboxing.md#protected-paths) nicht freigeben.

### `sandbox.filesystem.denyWrite`

Verhindern Sie, dass Befehle in der Sandbox in bestimmte Pfade schreiben, einschließlich Pfaden in einem Verzeichnis, das ansonsten beschreibbar ist.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Array von Pfadzeichenfolgen, unter Verwendung der [Sandbox-Pfadpräfixe](#sandbox-path-prefixes)
* **Standard**: nicht gesetzt

Dies verhindert, dass Befehle in der Sandbox die Systemkonfiguration ändern oder Binärdateien installieren:

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "denyWrite": ["/etc", "/usr/local/bin"]
    }
  }
}
```

Claude Code führt Einträge über jeden Einstellungsbereich zusammen, den die Sitzung lädt, und fügt die Pfade aus Ihren `Edit(...)`-deny-Berechtigungsregeln hinzu.

### `sandbox.filesystem.denyRead`

Verhindern Sie, dass Befehle in der Sandbox bestimmte Pfade lesen, z. B. Anmeldedateien, die die Standard-Leserichtlinie ansonsten offenlegen würde. Um eine Anmeldedatei zu schützen und sie über den Sandbox-Proxy nutzbar zu halten, siehe stattdessen [`sandbox.credentials`](#sandbox-credentials).

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Array von Pfadzeichenfolgen, unter Verwendung der [Sandbox-Pfadpräfixe](#sandbox-path-prefixes)
* **Standard**: nicht gesetzt, daher behalten Befehle in der Sandbox den [Standard-Lesezugriff](https://code.claude.com/docs/de/sandboxing.md#filesystem-isolation), der Anmeldedateien wie `~/.aws/credentials` einschließt

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/.aws/credentials"]
    }
  }
}
```

Claude Code führt Einträge über jeden Einstellungsbereich zusammen, den die Sitzung lädt, und fügt die Pfade aus Ihren `Read(...)`-deny-Berechtigungsregeln hinzu. Wenn [`filesystem.disabled`](#sandbox-filesystem-disabled) `true` ist, erzwingt Claude Code diese Einträge nicht.

### `sandbox.filesystem.allowRead`

Geben Sie das Lesen für bestimmte Pfade innerhalb eines Bereichs, den [`denyRead`](#sandbox-filesystem-denyread) blockiert, wieder frei, um einen auf den Workspace beschränkten Lesezugriff aufzubauen. Ein exakter oder Wildcard-`denyRead`-Eintrag bleibt innerhalb eines breiteren `allowRead` blockiert, wie die [Überlappungstabelle](https://code.claude.com/docs/de/sandboxing.md#configure-sandboxing) zeigt. Wenn ein Wildcard-`denyRead`-Eintrag wie `~/**/.env` auf ein Verzeichnis passt, blockiert Claude Code auch das Lesen seines Inhalts. Vor v2.1.236 gab Claude Code auf macOS die Pfade, auf die ein Wildcard-`denyRead`-Eintrag passte, überall dort wieder frei, wo ein breiterer `allowRead`-Eintrag sie abdeckte, und ließ den Inhalt eines passenden Verzeichnisses lesbar.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Array von Pfadzeichenfolgen, unter Verwendung der [Sandbox-Pfadpräfixe](#sandbox-path-prefixes)
* **Standard**: nicht gesetzt

Dies blockiert Lesevorgänge in Ihrem Home-Verzeichnis mit Ausnahme des Projekts selbst:

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["."]
    }
  }
}
```

Claude Code löst einen `.`-Eintrag in Projekteinstellungen zum Projekt-Root und in Benutzereinstellungen zu `~/.claude` auf. Claude Code führt Einträge über die Einstellungsdateien zusammen, die die Sitzung lädt, sofern [`allowManagedReadPathsOnly`](#sandbox-filesystem-allowmanagedreadpathsonly) nicht gesetzt ist, und lässt Einträge aus Repository-Einstellungen weg, solange [`permissions.blockReadsOutsideWorkingDirectories`](#sandboxed-commands-under-the-block) aktiviert ist. [Repository-Sperren](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox) können die Einträge eines Repositorys ebenfalls weglassen.

### `sandbox.filesystem.allowManagedReadPathsOnly`

Berücksichtigen Sie nur die [`allowRead`](#sandbox-filesystem-allowread)-Einträge, die aus verwalteten Einstellungen stammen, damit Entwickler den Lesezugriff auf Pfade, die Ihre Organisation blockiert hat, nicht wieder freigeben können. Claude Code führt weiterhin `denyRead`-Einträge aus jedem Einstellungsbereich zusammen, den die Sitzung lädt.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Boolescher Wert
  * `true`: Claude Code berücksichtigt nur die `allowRead`-Einträge aus verwalteten Einstellungen
  * `false`: `allowRead`-Einträge aus anderen Einstellungsdateien können einfließen
* **Standard**: `false`

Dies blockiert Lesevorgänge im Home-Verzeichnis, gibt `~/work` wieder frei und verhindert, dass Entwickler etwas anderes freigeben:

```json managed-settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["~/work"],
      "allowManagedReadPathsOnly": true
    }
  }
}
```

Siehe [Keep developers from widening the policy](https://code.claude.com/docs/de/sandboxing.md#keep-developers-from-widening-the-policy).

### `sandbox.filesystem.disabled`

Überspringen Sie die Dateisystem-Isolierung, während die Netzwerk-Isolierung erhalten bleibt. Befehle in der Sandbox erhalten uneingeschränkten Lese- und Schreibzugriff auf das Host-Dateisystem, und ihr ausgehender Netzwerkverkehr bleibt auf [`network.allowedDomains`](#sandbox-network-alloweddomains) beschränkt. Verwenden Sie es, wenn Sie die Sandbox einsetzen, um zu steuern, wohin Befehle sich verbinden, und nicht, was sie schreiben. Erfordert Claude Code v2.1.216 oder später.

* **Bereich**: [`User or managed`](#scopes). Wenn verwaltete Einstellungen `sandbox.filesystem` überhaupt konfigurieren oder einen `sandbox.credentials.files`-Eintrag mit `"mode": "deny"` auflisten, können nur verwaltete Einstellungen ihn setzen.
* **Typ**: Boolescher Wert
  * `true`: Claude Code überspringt die Dateisystem-Isolierung und behält die Netzwerk-Isolierung bei
  * `false`: Die Dateisystem-Isolierung bleibt aktiv
* **Standard**: `false`, daher bleibt die Dateisystem-Isolierung aktiv

Dies lässt das Dateisystem offen und beschränkt den ausgehenden Netzwerkverkehr auf GitHub und npm:

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "disabled": true
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}
```

Bei deaktivierter Schicht erzwingt Claude Code weder `denyRead`- noch `credentials.files`-`deny`-Einträge, während `credentials.envVars`-Einträge und angewendete `mask`-Einträge weiterhin funktionieren. [`autoAllowBashIfSandboxed`](#sandbox-autoallowbashifsandboxed) ist weiterhin standardmäßig `true`, setzen Sie es daher auf `false`, damit weiterhin nachgefragt wird. Siehe [Disable filesystem isolation](https://code.claude.com/docs/de/sandboxing.md#disable-filesystem-isolation) für die vollständige Liste der Quellen, die es setzen können, und was sich ändert, wenn die Isolierung deaktiviert ist. Erfordert Claude Code v2.1.216 oder später.

### `sandbox.ignoreViolations`

Unterdrücken Sie Sandbox-Verletzungsberichte für Pfade, bei denen Sie erwarten, dass ein Befehl sie prüft und abgewiesen wird, z. B. ein Tool, das beim Start `/etc/hosts` prüft, damit diese Ablehnungen weder als Verletzungen angezeigt werden noch in dem auftauchen, was Claude sieht. Die Sandbox blockiert den Zugriff weiterhin; nur der Bericht wird unterdrückt. Schlüssel sind Teilzeichenfolgen, die mit dem Befehl abgeglichen werden, wobei `*` auf jeden Befehl passt, und Werte sind Teilzeichenfolgen der Verletzung, die für diesen Befehl ignoriert werden sollen, z. B. ein Dateisystempfad.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Objekt, das eine Befehlsteilzeichenfolge einem Array von Verletzungsteilzeichenfolgen zuordnet, normalerweise Pfade
* **Standard**: nicht gesetzt, daher wird jede Verletzung gemeldet

```json settings.json theme={null}
{
  "sandbox": {
    "ignoreViolations": {
      "*": ["/etc/hosts"]
    }
  }
}
```

### `sandbox.enableWeakerNestedSandbox`

Führen Sie die Linux-Sandbox in einem unprivilegierten Docker-Container aus, in dem bubblewrap kein frisches `/proc` mounten kann. Stattdessen bindet die innere Sandbox das vorhandene `/proc` des Containers per Bind-Mount ein, wodurch Prozessinformationen offengelegt werden, die ein frisches Mount verbergen würde. Dies verringert die Sicherheit; verwenden Sie es nur, wenn der äußere Container bereits die benötigte Isolierung bietet.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Boolescher Wert
  * `true`: Die innere Sandbox bindet das vorhandene `/proc` des Containers per Bind-Mount ein, anstatt ein frisches zu mounten
  * `false`: Die Sandbox mountet ein frisches `/proc`, was in einem unprivilegierten Docker-Container nicht funktioniert
* **Standard**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "enableWeakerNestedSandbox": true
  }
}
```

Nur Linux und WSL2. Siehe [Bubblewrap fails to start inside a container](https://code.claude.com/docs/de/sandboxing.md#bubblewrap-fails-to-start-inside-a-container).

### `sandbox.enableWeakerNetworkIsolation`

Lassen Sie Befehle in der Sandbox auf macOS den System-TLS-Vertrauensdienst `com.apple.trustd.agent` erreichen. Go-basierte Tools wie `gh`, `gcloud` und `terraform` benötigen ihn, um TLS-Zertifikate zu überprüfen, wenn Sie [`network.httpProxyPort`](#sandbox-network-httpproxyport) mit einem MITM-Proxy und einer benutzerdefinierten CA verwenden. Dies verringert die Sicherheit, da über den Vertrauensdienst ein potenzieller Pfad zur Datenexfiltration geöffnet wird.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Boolescher Wert
  * `true`: Befehle in der Sandbox auf macOS können `com.apple.trustd.agent` erreichen
  * `false`: Befehle in der Sandbox auf macOS können den System-TLS-Vertrauensdienst nicht erreichen
* **Standard**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "enableWeakerNetworkIsolation": true
  }
}
```

Wenn Sie keinen MITM-Proxy verwenden, listen Sie die fehlschlagenden Tools stattdessen in [`excludedCommands`](#sandbox-excludedcommands) auf; siehe [Go-based CLIs fail TLS verification on macOS](https://code.claude.com/docs/de/sandboxing.md#go-based-clis-fail-tls-verification-on-macos).

### `sandbox.allowAppleEvents`

Lassen Sie Befehle in der Sandbox auf macOS Apple Events senden, die `open`, `osascript` und Tools, die URLs in einem Browser öffnen, benötigen; ohne diese Einstellung schlagen sie mit dem Fehler `-600` fehl. Dies hebt die Isolierung der Codeausführung auf: Befehle in der Sandbox können andere Anwendungen ohne Sandbox und ohne Benutzerabfrage starten und AppleScript-Befehle an laufende Anwendungen wie Terminal senden, vorbehaltlich der macOS-Abfrage zur Automatisierungszustimmung pro App (TCC).

* **Bereich**: [`User or managed`](#scopes)
* **Typ**: Boolescher Wert
  * `true`: Befehle in der Sandbox auf macOS können Apple Events senden
  * `false`: Befehle in der Sandbox auf macOS können keine Apple Events senden, daher schlagen `open` und `osascript` mit dem Fehler `-600` fehl
* **Standard**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "allowAppleEvents": true
  }
}
```

Um die Isolierung beizubehalten und trotzdem ein solches Tool auszuführen, fügen Sie es stattdessen zu [`excludedCommands`](#sandbox-excludedcommands) hinzu. Siehe [Apple Events on macOS](https://code.claude.com/docs/de/sandboxing.md#security-limitations).

### `sandbox.allowNestedUserNamespaces`

Lässt Befehle in der Sandbox unter Linux und WSL2 User-Namespaces erstellen, die die eigene Sandbox von Chromium und Electron, ein verschachteltes bubblewrap und `unshare` benötigen. Wenn Sie diesen Schlüssel auf `true` setzen, schalten Sie eine Sicherheitsgrenze aus: Code aus einem Befehl in der Sandbox kann am Ende außerhalb der Sandbox laufen. Verwenden Sie für rootless Podman oder Buildah stattdessen [`excludedCommands`](#sandbox-excludedcommands), da die Sandbox sie auch auf andere Weise stoppt. Erfordert Claude Code v2.1.305 oder neuer.

* **Geltungsbereich**: [`User or managed`](#scopes). Ein `true` zählt aus `~/.claude/settings.json`, aus mit `--settings` übergebenem JSON oder aus [verwalteten Einstellungen](https://code.claude.com/docs/de/managed-settings.md). Claude Code ignoriert ein `true` in der `.claude/settings.json` oder `.claude/settings.local.json` eines Projekts. In einer Sitzung, in der [`CLAUDE_CODE_SUBPROCESS_ENV_SCRUB`](https://code.claude.com/docs/de/env-vars#variables) auf `1` gesetzt ist, ignoriert Claude Code ein `true` aus jeder Quelle. Ein `false` zählt aus jeder Datei, gemäß dem [Vorrang der Einstellungen](https://code.claude.com/docs/de/settings.md#settings-precedence).
* **Typ**: Boolean
  * `true`: Befehle in der Sandbox können User-Namespaces erstellen
  * `false`: Dieser Schlüssel erlaubt nichts zusätzlich, und es gilt der Standard der Sandbox
* **Standard**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "allowNestedUserNamespaces": true
  }
}
```

Wenn dieser Schlüssel eingeschaltet ist, verlassen Sie sich auf keine der Einschränkungen der Sandbox, einschließlich [geschützter Pfade](https://code.claude.com/docs/de/sandboxing.md#protected-paths) und [`credentials.files`](#sandbox-credentials-files)-Einträge, um einen bösartigen Befehl aufzuhalten. Im [Auto-Allow-Modus](https://code.claude.com/docs/de/sandboxing.md#auto-allow-mode) kann dieser Befehl ohne Berechtigungsabfrage laufen. Wenn Ihre Organisation ein Sicherheitsteam hat, sprechen Sie sich mit diesem ab, bevor Sie den Schlüssel einschalten.

Die Lösung für Ihr Tool finden Sie unter [Chromium oder rootless Podman schlägt unter Linux in der Sandbox fehl](https://code.claude.com/docs/de/sandboxing.md#chromium-or-rootless-podman-fails-inside-the-sandbox-on-linux).

### `sandbox.ripgrep`

Verweisen Sie die Sandbox auf eine eigene ripgrep-Binärdatei statt auf die, die Claude Code verwendet, z. B. wenn Ihre Plattform ein anders gebautes `rg` benötigt.

* **Bereich**: [`User or managed`](#scopes)
* **Typ**: Objekt mit `command`, dem Pfad zur ripgrep-Binärdatei, und optional `args`, einem Array von Argumenten, die vorangestellt werden
* **Standard**: nicht gesetzt, daher verwendet die Sandbox dieselbe ripgrep-Binärdatei wie Claude Code. Das ist die gebündelte Binärdatei, sofern Sie [`USE_BUILTIN_RIPGREP`](https://code.claude.com/docs/de/env-vars) nicht auf `0` setzen

```json settings.json theme={null}
{
  "sandbox": {
    "ripgrep": {
      "command": "/usr/local/bin/rg"
    }
  }
}
```

### `sandbox.bwrapPath`

Verweisen Sie die Sandbox auf eine bubblewrap-Binärdatei, die außerhalb von `PATH` installiert ist, z. B. eine mitgelieferte Kopie auf einem vom Netzwerk isolierten Host. Claude Code verwendet den Pfad sowohl für die Abhängigkeitsprüfung beim Start als auch beim Umhüllen jedes Befehls in der Sandbox.

* **Bereich**: [`Managed`](#scopes). Claude Code liest es nur aus verwalteten Einstellungen, damit eine Benutzer-, Projekt- oder lokale Datei die Sandbox nicht auf eine andere Binärdatei verweisen kann.
* **Typ**: Zeichenfolge, ein absoluter Pfad; Claude Code verwirft einen relativen Pfad und greift auf die Suche in `PATH` zurück
* **Standard**: nicht gesetzt, daher sucht Claude Code `bwrap` in `PATH`

```json managed-settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "bwrapPath": "/opt/admin/bwrap"
  }
}
```

Nur Linux und WSL2.

### `sandbox.socatPath`

Verweisen Sie den Sandbox-Netzwerk-Proxy auf eine `socat`-Binärdatei, die außerhalb von `PATH` installiert ist.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Zeichenfolge, ein absoluter Pfad; Claude Code verwirft einen relativen Pfad und greift auf die Suche in `PATH` zurück
* **Standard**: nicht gesetzt, daher sucht Claude Code `socat` in `PATH`

```json managed-settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "socatPath": "/opt/admin/socat"
  }
}
```

Nur Linux und WSL2.

### `sandbox.credentials`

Deklarieren Sie die Anmeldedateien und Umgebungsvariablen, die [vor Befehlen in der Sandbox geschützt werden sollen](https://code.claude.com/docs/de/sandboxing.md#protect-credentials). Jeder Eintrag benennt eine Datei `path` oder eine Variable `name` und einen `mode`: `deny` verbirgt die Anmeldedaten in der Sandbox, und `mask` zeigt Befehlen in der Sandbox einen Platzhalter, während der [Sandbox-Proxy](https://code.claude.com/docs/de/sandboxing.md#mask-credentials) bei ausgehenden Anfragen den echten Wert einsetzt. Claude Code schützt nur die Einträge, die Sie auflisten; es gibt keine integrierte Denylist für Anmeldedaten.

* **Bereich**: [`Any file`](#scopes). Claude Code berücksichtigt `mask`-Einträge, `allowPlaintextInject`, `awsPairs` und `sigv4` nur aus Benutzereinstellungen, verwalteten Einstellungen und dem `--settings`-Flag.
* **Typ**: Objekt mit `files`, `envVars`, `allowPlaintextInject`, `awsPairs` und `sigv4`
* **Standard**: nicht gesetzt, daher werden keine Anmeldedaten geschützt

Dies verbirgt Ihre AWS-Anmeldedatei und entfernt `GITHUB_TOKEN` aus Befehlen in der Sandbox:

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "files": [{ "path": "~/.aws/credentials", "mode": "deny" }],
      "envVars": [{ "name": "GITHUB_TOKEN", "mode": "deny" }]
    }
  }
}
```

Der `deny`-Dateischutz ist Teil der Dateisystem-Schicht, daher gilt er nicht, wenn Sie [die Dateisystem-Isolierung deaktivieren](https://code.claude.com/docs/de/sandboxing.md#disable-filesystem-isolation); der Schutz von Umgebungsvariablen gilt weiterhin.

#### Ungültige Anmeldedaten-Einträge in verwalteten Einstellungen

Wenn ein verwalteter `sandbox.credentials`-Eintrag die Validierung nicht besteht, schützt Claude Code die Anmeldedaten weiterhin, soweit möglich:

* Ein Eintrag in `files` oder `envVars`, der noch einen gültigen `path` oder `name` und einen `mode` von `mask` oder `deny` hat, z. B. einer, dessen `extract`-Muster keine Erfassungsgruppe hat, wird mit einer Warnung auf `mode: "deny"` herabgestuft, sodass die Anmeldedaten blockiert statt maskiert bleiben, bis Sie den Eintrag korrigieren. Ein herabgestufter `files`-Eintrag fixiert [`filesystem.disabled`](https://code.claude.com/docs/de/sandboxing#disable-filesystem-isolation) wie ein expliziter `deny`-Eintrag, und die Warnung weist darauf hin, dass seine Lesesperre nicht erzwungen wird, wenn verwaltete Einstellungen die Dateisystem-Isolierung ausschalten.
* Ein Eintrag mit einem unbekannten `mode` oder einem ungültigen `path` oder `name` wird entfernt.
* In jedem Fall wird gewarnt; ob ein Eintrag herabgestuft oder entfernt wird, die verbleibenden gültigen Einträge werden weiterhin erzwungen.

Gilt in v2.1.191 und später; vor v2.1.221 wurde jeder ungültige Eintrag entfernt. Für die anderen verwalteten Schlüssel mit feldweiser Behandlung siehe [Invalid entries in managed settings](https://code.claude.com/docs/de/managed-settings.md#invalid-entries-in-managed-settings).

### `sandbox.credentials.files`

Schützen Sie Anmeldedateien oder Verzeichnisse vor Befehlen in der Sandbox. Mit `"mode": "deny"` blockiert Claude Code Lesevorgänge des Pfads in der Sandbox, dieselbe Lesesperre wie bei [`sandbox.filesystem.denyRead`](#sandbox-filesystem-denyread). Mit `"mode": "mask"` lesen Befehle in der Sandbox auf Linux und WSL2 eine Sentinel-Kopie der Datei, und der Sandbox-Proxy setzt bei ausgehenden Anfragen an die `injectHosts` dieses Eintrags den echten Wert ein; auf macOS ist die Datei in der Sandbox stattdessen nicht lesbar. `"mode": "mask"` erfordert Claude Code v2.1.221 oder später.

* **Bereich**: [`Any file`](#scopes). Claude Code verwirft `mask`-Einträge aus der Projektdatei `.claude/settings.json` und der lokalen Datei `.claude/settings.local.json`.
* **Typ**: Array von Objekten, jedes mit `path` und einem `mode` von `"deny"` oder `"mask"`, plus die optionalen [Maskierungsfelder für Dateien](#mask-fields-for-files)
* **Standard**: nicht gesetzt, daher werden keine Anmeldedateien geschützt

Dies verbirgt Ihre AWS-Anmeldedatei und maskiert die `gh`-Hosts-Datei, wobei der echte Wert nur bei Anfragen an `api.github.com` eingesetzt wird:

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "files": [
        { "path": "~/.aws/credentials", "mode": "deny" },
        { "path": "~/.config/gh/hosts.yml", "mode": "mask", "injectHosts": ["api.github.com"] }
      ]
    }
  }
}
```

Pfade verwenden dieselben [Präfixe](#sandbox-path-prefixes) wie die `sandbox.filesystem.*`-Einstellungen, und Claude Code führt die Arrays aus jedem Einstellungsbereich zusammen, den die Sitzung lädt. [Protect credentials](https://code.claude.com/docs/de/sandboxing.md#protect-credentials) behandelt, was aus Quellen, die Sie mit `--setting-sources` ausschließen, weiterhin gilt. `mask`-Einträge erfordern Claude Code v2.1.221 oder später.

Die `mask`-Ersetzung läuft nur über den Sandbox-Proxy, setzen Sie daher [`sandbox.network.tlsTerminate`](#sandbox-network-tlsterminate) oder für Testnetzwerke mit einfachem HTTP [`allowPlaintextInject`](#sandbox-credentials-allowplaintextinject). `mask` gilt für eine einzelne Datei, listen Sie daher jede Anmeldedatei einzeln auf. Claude Code akzeptiert die `mask`-Felder bei einem `deny`-Eintrag, ignoriert sie aber. [Mask credentials](https://code.claude.com/docs/de/sandboxing.md#mask-credentials) behandelt, welche Einstellungsquellen berücksichtigt werden, und [Mask credential files](https://code.claude.com/docs/de/sandboxing.md#mask-credential-files) behandelt, wann ein Eintrag auf `deny` zurückfällt.

#### Maskierungsfelder für Dateien

Ein `mask`-Eintrag akzeptiert diese optionalen Felder. Ohne `extract` oder `decode` ersetzt Claude Code den gesamten Dateiinhalt durch einen Sentinel. Auf macOS mit aktivierter Dateisystem-Isolierung wendet Claude Code einen `mask`-Eintrag als `deny` an, bevor `extract` oder `decode` ausgeführt wird; siehe [Mask credential files](https://code.claude.com/docs/de/sandboxing.md#mask-credential-files).

| Feld | Typ | Funktion |
| :- | :- | :- |
| `extract` | Zeichenfolge, ein regulärer Ausdruck mit mindestens einer Erfassungsgruppe | Maskiert nur den Text, den Gruppe 1 jedes Treffers erfasst, damit der Rest der Datei parsebar bleibt. Wenn zusätzlich `decode` gesetzt ist, prüft Claude Code jede Erfassung als mögliches JWT, anstatt sie direkt zu ersetzen. Erfordert v2.1.221 oder später |
| `onExtractNoMatch` | `"warn"`, `"deny"` oder `"error"`; Standard `"warn"` | Was passiert, wenn `extract` oder `decode` nichts zum Maskieren findet. `warn` lässt die Datei in der Sandbox unverändert lesbar, `deny` macht sie unlesbar, und `error` stoppt die Einrichtung der Sandbox, bis Sie die Konfiguration korrigieren. Claude Code behandelt `deny` als `error`, wenn die Lesesperre nicht erzwungen würde, weil Sie [die Dateisystem-Isolierung deaktivieren](https://code.claude.com/docs/de/sandboxing.md#disable-filesystem-isolation) oder ein [`sandbox.filesystem.allowRead`](#sandbox-filesystem-allowread)-Eintrag den Pfad wieder freigibt. Erfordert v2.1.221 oder später; der `decode`-Fall erfordert v2.1.224 oder später |
| `decode` | die Zeichenfolge `"jwt"` | Findet JSON Web Tokens (JWTs) in der Datei, mit einem integrierten Muster oder mit `extract`, falls gesetzt, verifiziert jeden Kandidaten und ersetzt ihn durch ein strukturell gültiges gefälschtes Token, damit Code in der Sandbox, der das Token dekodiert, weiterhin funktioniert. Wenn kein Kandidat verifiziert wird, bestimmt `onExtractNoMatch` das Ergebnis. Erfordert v2.1.224 oder später |
| `maskClaims` | Array von Zeichenfolgen, mindestens ein Claim-Name; erfordert `decode` | Maskiert nur die benannten Top-Level-Claims der Payload in jedem verifizierten JWT und baut das Token um die geänderte Payload herum neu auf, damit die anderen Claims lesbar bleiben. Wenn kein benannter Claim passt, bestimmt `onExtractNoMatch` das Ergebnis. Erfordert v2.1.224 oder später |
| `maskDuplicates` | Boolescher Wert, Standard `false` | Ersetzt auch wörtliche Kopien jedes maskierten Werts an anderen Stellen der Datei, z. B. ein in einen Kommentar eingefügtes Geheimnis. Claude Code gleicht rohe Teilzeichenfolgen ab, verwenden Sie es daher nur für lange Geheimnisse mit hoher Entropie. Wird nur berücksichtigt, wenn `extract` oder `decode` gesetzt ist. Erfordert v2.1.221 oder später |
| `injectHosts` | Array von Zeichenfolgen, jede ein Host, den [`sandbox.network.allowedDomains`](#sandbox-network-alloweddomains) ebenfalls zulässt | Grenzt die Hosts ein, bei denen der Sandbox-Proxy den echten Wert einsetzt. Wenn nicht gesetzt, setzt der Proxy ihn bei Anfragen an jeden Host in `sandbox.network.allowedDomains` ein. Erfordert v2.1.221 oder später |

Dies maskiert nur den `oauth_token`-Wert in der `gh`-Hosts-Datei, ersetzt jede andere Kopie davon in der Datei, macht die Datei unlesbar, wenn das Muster auf nichts passt, und setzt das echte Token nur bei Anfragen an `api.github.com` ein:

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "files": [
        {
          "path": "~/.config/gh/hosts.yml",
          "mode": "mask",
          "extract": "oauth_token:\\s*(\\S+)",
          "maskDuplicates": true,
          "onExtractNoMatch": "deny",
          "injectHosts": ["api.github.com"]
        }
      ]
    }
  }
}
```

### `sandbox.credentials.envVars`

Schützen Sie Umgebungsvariablen vor Befehlen in der Sandbox. Mit `"mode": "deny"` entfernt Claude Code die Variable aus der Umgebung von Befehlen in der Sandbox. Mit `"mode": "mask"` sehen Befehle in der Sandbox einen sitzungsspezifischen Sentinel-Wert, und der Sandbox-Proxy setzt bei ausgehenden Anfragen an die `injectHosts` dieses Eintrags den echten Wert ein, sodass Tools wie `gh` und `npm` sich weiterhin authentifizieren, ohne jemals die echten Anmeldedaten zu besitzen.

* **Bereich**: [`Any file`](#scopes). Claude Code verwirft `mask`-Einträge aus der Projektdatei `.claude/settings.json` und der lokalen Datei `.claude/settings.local.json`.
* **Typ**: Array von Objekten, jedes mit `name` und einem `mode` von `"deny"` oder `"mask"`, plus die optionalen [Maskierungsfelder für Umgebungsvariablen](#mask-fields-for-environment-variables)
* **Standard**: nicht gesetzt, daher werden keine Umgebungsvariablen geschützt

Dies entfernt `NPM_TOKEN` aus Befehlen in der Sandbox und maskiert `GITHUB_TOKEN`, wobei der echte Wert nur bei Anfragen an `api.github.com` eingesetzt wird:

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "envVars": [
        { "name": "NPM_TOKEN", "mode": "deny" },
        { "name": "GITHUB_TOKEN", "mode": "mask", "injectHosts": ["api.github.com"] }
      ]
    }
  }
}
```

Der `name` muss mit einem Buchstaben oder Unterstrich beginnen und darf nur Buchstaben, Ziffern und Unterstriche enthalten. Claude Code führt die Arrays aus jedem Einstellungsbereich zusammen, den die Sitzung lädt, und wendet `deny` an, wenn dieselbe Variable mit beiden Modi erscheint. [Protect credentials](https://code.claude.com/docs/de/sandboxing.md#protect-credentials) behandelt, was aus Quellen, die Sie mit `--setting-sources` ausschließen, weiterhin gilt.

Die `mask`-Ersetzung läuft nur über den Sandbox-Proxy, setzen Sie daher [`sandbox.network.tlsTerminate`](#sandbox-network-tlsterminate) oder für Testnetzwerke mit einfachem HTTP [`allowPlaintextInject`](#sandbox-credentials-allowplaintextinject); siehe [Mask credentials](https://code.claude.com/docs/de/sandboxing.md#mask-credentials). Claude Code akzeptiert die `mask`-Felder bei einem `deny`-Eintrag, ignoriert sie aber.

#### Maskierungsfelder für Umgebungsvariablen

Ein `mask`-Eintrag akzeptiert diese optionalen Felder. Ohne `extract` oder `decode` ersetzt Claude Code den gesamten Wert durch einen Sentinel. `extract` und `decode` können nicht im selben Eintrag kombiniert werden.

| Feld | Typ | Funktion |
| :- | :- | :- |
| `extract` | Zeichenfolge, ein regulärer Ausdruck mit mindestens einer Erfassungsgruppe | Maskiert nur den Text, den Gruppe 1 jedes Treffers erfasst, z. B. das Passwort in einer `DATABASE_URL`-Verbindungszeichenfolge, damit der Rest des Werts parsebar bleibt. Erfordert v2.1.224 oder später |
| `onExtractNoMatch` | `"warn"`, `"deny"` oder `"error"`; Standard `"warn"`. Bei einem Eintrag mit `decode` wird nur `"warn"` akzeptiert | Was passiert, wenn `extract` auf nichts passt. `warn` gibt die Variable unmaskiert weiter, `deny` entfernt sie in der Sandbox, und `error` stoppt die Einrichtung der Sandbox, bis Sie die Konfiguration korrigieren. Erfordert v2.1.224 oder später |
| `decode` | die Zeichenfolge `"jwt"` | Verifiziert, dass der gesamte Wert ein JWT ist, und ersetzt ihn durch ein strukturell gültiges gefälschtes Token, damit Code in der Sandbox, der das Token dekodiert, weiterhin funktioniert; der Proxy setzt beim ausgehenden Verkehr das gesamte echte Token ein. Ein Wert, der nicht verifiziert wird, wird mit einer Warnung unmaskiert weitergegeben. Erfordert v2.1.224 oder später |
| `maskClaims` | Array von Zeichenfolgen, mindestens ein Claim-Name; erfordert `decode` | Maskiert nur die benannten Top-Level-Claims der Payload im dekodierten JWT und baut das Token um die geänderte Payload herum neu auf, damit die anderen Claims lesbar bleiben. Wenn kein benannter Claim passt, wird die Variable mit einer Warnung unmaskiert weitergegeben. Erfordert v2.1.224 oder später |
| `injectHosts` | Array von Zeichenfolgen, jede ein Host, den [`sandbox.network.allowedDomains`](#sandbox-network-alloweddomains) ebenfalls zulässt | Grenzt die Hosts ein, bei denen der Sandbox-Proxy den echten Wert einsetzt. Wenn nicht gesetzt, setzt der Proxy ihn bei Anfragen an jeden Host in `sandbox.network.allowedDomains` ein. Schreiben Sie ein IPv6-Ziel als bloße komprimierte Adresse, z. B. `"::1"`, nicht in der geklammerten Form; siehe [IPv6 destinations in `injectHosts`](https://code.claude.com/docs/de/sandboxing#ipv6-destinations-in-injecthosts) |

Dies maskiert nur das Passwort in `DATABASE_URL`, entfernt die Variable, wenn das Muster auf nichts passt, und maskiert ein JWT in `SERVICE_JWT`, wobei jeder Claim außer `api_key` lesbar bleibt:

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "envVars": [
        {
          "name": "DATABASE_URL",
          "mode": "mask",
          "extract": "://[^:]+:([^@]+)@",
          "onExtractNoMatch": "deny"
        },
        {
          "name": "SERVICE_JWT",
          "mode": "mask",
          "decode": "jwt",
          "maskClaims": ["api_key"]
        }
      ]
    }
  }
}
```

### `sandbox.credentials.allowPlaintextInject`

Erlauben Sie die `mask`-Ersetzung sowohl bei einfachen HTTP-Anfragen als auch bei TLS-terminiertem HTTPS. Bei einfachem HTTP ist die Identität des Upstream-Servers nicht verifiziert und die Anmeldedaten werden im Klartext übertragen, lassen Sie dies daher außerhalb vertrauenswürdiger Testnetzwerke deaktiviert.

* **Bereich**: [`User or managed`](#scopes)
* **Typ**: Boolescher Wert
  * `true`: Claude Code erlaubt die `mask`-Ersetzung sowohl bei einfachen HTTP-Anfragen als auch bei TLS-terminiertem HTTPS
  * `false`: Claude Code erlaubt die `mask`-Ersetzung nur bei TLS-terminiertem HTTPS
* **Standard**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "allowPlaintextInject": true
    }
  }
}
```

### `sandbox.credentials.awsPairs`

Gruppieren Sie maskierte Umgebungsvariablen, die zusammen AWS-Anmeldedaten für die [SigV4-Neusignierung](https://code.claude.com/docs/de/sandboxing.md#re-sign-aws-requests) bilden, wenn Ihre Anmeldedaten in Variablen mit nicht standardmäßigen Namen liegen. Claude Code verknüpft das konventionelle Trio `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` und `AWS_SESSION_TOKEN` automatisch, wenn Sie deren vollständige Werte maskieren, daher benötigen Sie diesen Schlüssel nur für andere Namen. Erfordert Claude Code v2.1.224 oder später.

* **Bereich**: [`User or managed`](#scopes)
* **Typ**: Array von Objekten, jedes mit `accessKeyIdVar`, `secretAccessKeyVar` und optional `sessionTokenVar`, die `sandbox.credentials.envVars`-Einträge benennen
* **Standard**: nicht gesetzt, daher wird nur das konventionelle Trio gepaart

Dies verknüpft drei benutzerdefiniert benannte Variablen zu einem AWS-Anmeldedatensatz für die Neusignierung:

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "awsPairs": [
        {
          "accessKeyIdVar": "MY_KEY_ID",
          "secretAccessKeyVar": "MY_SECRET_KEY",
          "sessionTokenVar": "MY_SESSION_TOKEN"
        }
      ]
    }
  }
}
```

Jede benannte Variable muss ein `mask`-Eintrag für den gesamten Wert in [`sandbox.credentials.envVars`](#sandbox-credentials-envvars) sein, ohne `extract` oder `decode`, und kann über alle Paare hinweg nur einen Slot belegen. Außerdem gelten diese Regeln:

* Der Proxy signiert Anfragen an die Hosts neu, die in den `injectHosts` des Eintrags für die Zugriffsschlüssel-ID aufgeführt sind
* Wenn `sessionTokenVar` gesetzt ist, sendet der Proxy das echte Token bei neu signierten Anfragen als `x-amz-security-token`
* Wenn Sie eine der konventionellen Variablen in einem Paar benennen, ersetzt dies die automatische Paarung

### `sandbox.credentials.sigv4`

Wählen Sie, was der Sandbox-Proxy mit AWS-Anfrageformen macht, die er [nicht neu signieren kann](https://code.claude.com/docs/de/sandboxing.md#re-sign-aws-requests): `streaming` für aws-chunked-Streaming-Uploads, `presigned` für vorsignierte URLs und `sigv4a` für asymmetrische SigV4A-Signaturen. Dies gilt nur für Anfragen, die mit der Platzhalter-Zugriffsschlüssel-ID eines maskierten Paars signiert sind. Erfordert Claude Code v2.1.224 oder später.

* **Bereich**: [`User or managed`](#scopes)
* **Typ**: Objekt mit `streaming`, `presigned` und `sigv4a`, jeweils einer der folgenden Werte:
  * `"deny"`: Der Proxy lässt die Anfrage fehlschlagen
  * `"passthrough"`: Der Proxy leitet die mit dem maskierten Platzhalter signierte Anfrage weiter, sodass das Tool die eigene Ablehnung von AWS erhält
* **Standard**: nicht gesetzt, daher ist jede Form `"deny"`

Dies leitet Streaming-Uploads weiter, anstatt sie am Proxy scheitern zu lassen:

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "sigv4": {
        "streaming": "passthrough"
      }
    }
  }
}
```

Mit `deny` lässt der Proxy die Anfrage fehlschlagen. Mit `passthrough` leitet der Proxy die Anfrage mit ihrer aus dem maskierten Platzhalter berechneten Signatur weiter, sodass AWS sie ablehnt und das aufrufende Tool die eigene Antwort von AWS statt eines Proxy-Fehlers erhält.

### `sandbox.network`

Legen Sie fest, welche Hosts, Ports und Sockets Befehle in der Sandbox erreichen können. Die Sandbox leitet ausgehenden Verkehr über einen Proxy, der diese Listen erzwingt; siehe [Network isolation](https://code.claude.com/docs/de/sandboxing.md#network-isolation) dafür, wie der Proxy entscheidet und wann er nachfragt.

* **Bereich**: [`Any file`](#scopes). `strictAllowlist`, `allowManagedDomainsOnly` und `tlsTerminate` werden aus weniger Quellen gelesen, wie ihre Einträge angeben.
* **Typ**: Objekt mit den unten aufgeführten Unterschlüsseln
* **Standard**: nicht gesetzt, daher werden keine Domänen vorab erlaubt, und Ihr Berechtigungsmodus entscheidet, [was mit jedem neuen Host geschieht](https://code.claude.com/docs/de/sandboxing.md#hosts-outside-your-allowed-domains)

Dies erlaubt GitHub und npm vorab, blockiert `uploads.github.com` und lässt Befehle an localhost binden:

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"],
      "deniedDomains": ["uploads.github.com"],
      "allowLocalBinding": true
    }
  }
}
```

Claude Code führt die Array-Unterschlüssel über Einstellungsbereiche zusammen, sodass ein Projekt Domänen zu Ihrer Benutzerliste hinzufügen kann, sofern keine [Repository-Sperre](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox) greift. `WebFetch(domain:...)`-allow- und -deny-[Berechtigungsregeln](https://code.claude.com/docs/de/sandboxing.md#permission-rules) speisen dieselben Allow- und Deny-Listen.

### `sandbox.network.allowUnixSockets`

Listen Sie die Unix-Socket-Pfade auf, mit denen Befehle in der Sandbox auf macOS eine Verbindung herstellen können. Claude Code ignoriert diese Liste auf Linux und WSL2, wo der seccomp-Filter Socket-Pfade nicht prüfen kann; verwenden Sie dort stattdessen [`allowAllUnixSockets`](#sandbox-network-allowallunixsockets).

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Array von Zeichenfolgen, jede ein Socket-Pfad
* **Standard**: nicht gesetzt, daher blockiert die macOS-Sandbox jeden Unix-Socket

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"]
    }
  }
}
```

Ein Socket-Pfad kann weitreichenden Zugriff gewähren: Wenn Sie beispielsweise `/var/run/docker.sock` erlauben, kann ein Befehl in der Sandbox den Docker-Daemon steuern. Siehe [Security limitations](https://code.claude.com/docs/de/sandboxing.md#security-limitations).

### `sandbox.network.allowAllUnixSockets`

Lassen Sie Befehle in der Sandbox eine Verbindung zu jedem Unix-Socket herstellen. Auf Linux und WSL2 blockiert der [seccomp-Filter](https://code.claude.com/docs/de/sandboxing.md#set-up-linux-and-wsl2) der Sandbox `socket(AF_UNIX, ...)`-Aufrufe, daher ist dies dort die einzige Möglichkeit, Unix-Sockets zu erlauben. Wenn der Filter fehlt, was `/sandbox` auf seiner Registerkarte Dependencies meldet, blockiert die Sandbox Unix-Socket-Aufrufe nicht. Siehe [Set up Linux and WSL2](https://code.claude.com/docs/de/sandboxing.md#set-up-linux-and-wsl2) dafür, woher der Filter stammt.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Boolean
  * `true`: Befehle in der Sandbox können sich mit jedem Unix-Socket verbinden. Unter Linux und WSL2 können sie sich außerdem mit VM-Sockets verbinden, der Adressfamilie `AF_VSOCK`
  * `false`: Die Sandbox blockiert Unix-Socket-Verbindungen: unter macOS mit Ausnahme der Pfade in `allowUnixSockets` und unter Linux und WSL2 über den seccomp-Filter, sofern er vorhanden ist
* **Standard**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowAllUnixSockets": true
    }
  }
}
```

Auf WSL2 öffnet `true` außerdem wieder den Interop-Socket, der Windows-Binärdateien wie `cmd.exe` und `powershell.exe` startet.

### `sandbox.network.allowLocalBinding`

Lassen Sie Befehle in der Sandbox auf macOS an Netzwerk-Ports lauschen, z. B. um einen Dev-Server zu starten, und sich mit jedem Port auf localhost verbinden. Ein Befehl, der auf einer Nicht-Loopback-Adresse lauscht, nimmt Verbindungen von anderen Rechnern an. Der Schlüssel hat auf Linux und WSL2 keine Wirkung, wo jeder Befehl in der Sandbox eine eigene Loopback-Schnittstelle hat. Um von Linux oder WSL2 aus einen Server auf dem Host zu erreichen, siehe [A command fails to reach a server on localhost](https://code.claude.com/docs/de/sandboxing.md#a-command-fails-to-reach-a-server-on-localhost).

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Boolescher Wert
  * `true`: Befehle in der Sandbox auf macOS können auf jeder lokalen Adresse lauschen und sich mit jedem Port auf localhost verbinden
  * `false`: Befehle in der Sandbox auf macOS können weder auf einem Port lauschen noch sich direkt mit Servern auf localhost verbinden
* **Standard**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowLocalBinding": true
    }
  }
}
```

### `sandbox.network.allowMachLookup`

Listen Sie zusätzliche XPC- und Mach-Servicenamen auf, die die macOS-Sandbox nachschlagen darf. Tools, die über XPC kommunizieren, wie der iOS-Simulator oder Playwright, benötigen hier einen Eintrag für ihre Services.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Typ**: Array von Zeichenfolgen, jede ein Servicename; ein einzelnes nachgestelltes `*` passt auf ein Präfix, und `"*"` allein passt auf jeden Service
* **Standard**: nicht gesetzt

Dies erlaubt jeden Service unter dem Präfix `com.apple.coresimulator.`:

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowMachLookup": ["com.apple.coresimulator.*"]
    }
  }
}
```

### `sandbox.network.allowedDomains`

Erlauben Sie Domänen für ausgehenden Verkehr von Befehlen in der Sandbox vorab, sodass die Sandbox für sie nicht nachfragt. Wildcards wie `*.example.com` passen auf Subdomänen, und ein optionales `:port`-Suffix beschränkt einen Eintrag auf einen Port; ein Eintrag ohne Port passt auf jeden Port.

* **Bereich**: [`Any file`](#scopes), mit [Einschränkungen für Projekt- und lokale Einstellungen](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox). Nur verwaltete Einstellungen, wenn [`allowManagedDomainsOnly`](#sandbox-network-allowmanageddomainsonly) gesetzt ist.
* **Typ**: Array von Zeichenfolgen, jede eine Domäne, ein Wildcard-Muster oder ein IP-Literal, mit einem optionalen `:port`-Suffix
* **Standard**: nicht gesetzt, daher entscheidet Ihr Berechtigungsmodus, [was mit jedem neuen Host geschieht](https://code.claude.com/docs/de/sandboxing.md#hosts-outside-your-allowed-domains)

Dies erlaubt GitHub auf jedem Port, jede npm-Subdomäne und einen API-Host nur auf Port 443 vorab:

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org", "api.example.com:443"]
    }
  }
}
```

Schreiben Sie IPv6-Literale in eckigen Klammern, mit optionalem Port: `"[::1]"` erlaubt jeden Port und `"[::1]:443"` einen Port. Die geklammerte Form erfordert Claude Code v2.1.229 oder später. Siehe [IPv6 addresses in domain lists](https://code.claude.com/docs/de/sandboxing.md#ipv6-addresses-in-domain-lists).

### `sandbox.network.deniedDomains`

Blockieren Sie Domänen für ausgehenden Verkehr von Befehlen in der Sandbox, mit derselben Wildcard-, Port- und IPv6-Syntax wie bei [`allowedDomains`](#sandbox-network-alloweddomains). Eine blockierte Domäne bleibt blockiert, auch wenn ein `allowedDomains`-Eintrag ebenfalls auf sie passt.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Array von Zeichenfolgen, jede eine Domäne, ein Wildcard-Muster oder ein IP-Literal, mit einem optionalen `:port`-Suffix
* **Standard**: nicht gesetzt

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "deniedDomains": ["sensitive.cloud.example.com"]
    }
  }
}
```

Claude Code führt diese Liste aus jeder Einstellungsquelle zusammen, die die Sitzung lädt, auch wenn `allowManagedDomainsOnly` gesetzt ist, sodass ein Entwickler die Denylist jederzeit verschärfen kann. Für IPv6-Literale siehe [IPv6 addresses in domain lists](https://code.claude.com/docs/de/sandboxing.md#ipv6-addresses-in-domain-lists).

Ein Eintrag, der mit dem nachgestellten Punkt geschrieben ist, der einen vollständig qualifizierten Domänennamen kennzeichnet, wie `example.com.`, blockiert dieselben Verbindungen wie `example.com`.

### `sandbox.network.strictAllowlist`

Verweigern Sie Befehlen in der Sandbox den Zugriff auf Hosts außerhalb der Allowlist, anstatt um Genehmigung zu bitten. Die Allowlist besteht aus [`allowedDomains`](#sandbox-network-alloweddomains) plus Domänen aus `WebFetch(domain:...)`-allow-Regeln, oder nur aus den Einträgen der verwalteten Einstellungen, wenn [`allowManagedDomainsOnly`](#sandbox-network-allowmanageddomainsonly) gesetzt ist. [Locks that apply without an admin-required sandbox](https://code.claude.com/docs/de/sandboxing.md#locks-that-apply-without-an-admin-required-sandbox) behandelt die Einträge eines Repositorys. Erfordert Claude Code v2.1.219 oder später.

* **Bereich**: [`User or managed`](#scopes). Ein Repository kann es weder ein- noch ausschalten.
* **Typ**: Boolescher Wert
  * `true`: Claude Code verweigert Befehlen in der Sandbox den Zugriff auf Hosts außerhalb der Allowlist
  * `false`: Sofern keine andere vertrauenswürdige Einstellungsdatei `true` setzt, entscheidet Claude Code über einen Host außerhalb der Allowlist anhand des Berechtigungsmodus, anstatt ihn direkt zu verweigern: Im Auto-Modus prüft es den Host gegen die [per-command allowed domains](https://code.claude.com/docs/de/sandboxing.md#per-command-allowed-domains-in-auto-mode) des Befehls, im `dontAsk`-Modus verweigert es, im `bypassPermissions`-Modus und in interaktiven Terminal-Sitzungen im Plan-Modus, in denen Bypass verfügbar ist, erlaubt es, und andernfalls fragt es bei Ihnen nach
* **Standard**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "strictAllowlist": true
    }
  }
}
```

Claude Code erzwingt dies nur für Befehle in der Sandbox; In-Process-Tools wie `WebFetch` folgen weiterhin ihren [Berechtigungsregeln](https://code.claude.com/docs/de/sandboxing.md#permission-rules). Wenn eine der berücksichtigten Quellen es auf `true` setzt, bleibt es aktiv. Siehe [Network isolation](https://code.claude.com/docs/de/sandboxing.md#network-isolation). Erfordert Claude Code v2.1.219 oder später.

### `sandbox.network.allowManagedDomainsOnly`

Sperren Sie die Netzwerk-Allowlist auf das, was verwaltete Einstellungen definieren. Claude Code berücksichtigt dann nur `allowedDomains` und `WebFetch(domain:...)`-allow-Regeln aus verwalteten Einstellungen, ignoriert Domänen aus Benutzer-, Projekt-, lokalen und `--settings`-Einstellungen und blockiert eine nicht zulässige Domäne automatisch, anstatt nachzufragen.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Boolescher Wert
  * `true`: Claude Code berücksichtigt nur `allowedDomains` und `WebFetch(domain:...)`-allow-Regeln aus verwalteten Einstellungen und blockiert eine nicht zulässige Domäne, anstatt nachzufragen
  * `false`: Domänen aus anderen Einstellungsdateien können in die Allowlist einfließen
* **Standard**: `false`

Dies sperrt die Allowlist auf GitHub und npm und ignoriert alle Domänen, die Entwickler hinzufügen:

```json managed-settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowManagedDomainsOnly": true,
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}
```

Solange der Schlüssel `true` ist, ist die Sandbox [vom Admin vorgeschrieben](https://code.claude.com/docs/de/sandboxing.md#repository-settings-under-an-admin-required-sandbox), und nur verwaltete Einstellungen können einen [Proxy-Port](#sandbox-network-httpproxyport) setzen.

Blockierte Domänen werden weiterhin aus jeder Quelle zusammengeführt, die die Sitzung lädt. Siehe [Keep developers from widening the policy](https://code.claude.com/docs/de/sandboxing.md#keep-developers-from-widening-the-policy).

### `sandbox.network.httpProxyPort`

Verweisen Sie die Sandbox auf Ihren eigenen HTTP-Proxy statt auf den, den Claude Code ausführt. Organisationen tun dies, um HTTPS-Verkehr zu prüfen, eigene Filterregeln anzuwenden oder Anfragen zu protokollieren. Ihr Proxy übernimmt die Filterung, und Claude Code wendet seine Domänenlisten und Netzwerkabfragen nicht mehr auf den dorthin gesendeten Verkehr an. Wenn nicht gesetzt, startet Claude Code seinen eigenen Proxy für HTTP-Verkehr.

* **Bereich**: [`Any file`](#scopes), sofern nicht [andere Sandbox-Einstellungen einschränken, welche Dateien einen Port setzen können](https://code.claude.com/docs/de/sandboxing.md#custom-proxy-configuration)
* **Typ**: Zahl, ein lokaler TCP-Port
* **Standard**: nicht gesetzt, daher führt Claude Code seinen eigenen Proxy aus

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "httpProxyPort": 8080
    }
  }
}
```

Setzen Sie zusätzlich [`socksProxyPort`](#sandbox-network-socksproxyport), wenn Ihr Proxy auch SOCKS-Verkehr übernehmen soll; wenn nur einer der beiden gesetzt ist, führt Claude Code für das andere Protokoll weiterhin seinen eigenen Proxy aus. Siehe [Custom proxy configuration](https://code.claude.com/docs/de/sandboxing.md#custom-proxy-configuration).

### `sandbox.network.socksProxyPort`

Verweisen Sie die Sandbox auf Ihren eigenen SOCKS5-Proxy statt auf den, den Claude Code ausführt. Ihr Proxy übernimmt die Filterung, und Claude Code wendet seine Domänenlisten und Netzwerkabfragen nicht mehr auf den dorthin gesendeten Verkehr an. Wenn nicht gesetzt, startet Claude Code seinen eigenen Proxy für SOCKS-Verkehr.

* **Bereich**: [`Any file`](#scopes), sofern nicht [andere Sandbox-Einstellungen einschränken, welche Dateien einen Port setzen können](https://code.claude.com/docs/de/sandboxing.md#custom-proxy-configuration)
* **Typ**: Zahl, ein lokaler TCP-Port
* **Standard**: nicht gesetzt, daher führt Claude Code seinen eigenen Proxy aus

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "socksProxyPort": 8081
    }
  }
}
```

Siehe [Custom proxy configuration](https://code.claude.com/docs/de/sandboxing.md#custom-proxy-configuration).

### `sandbox.network.tlsTerminate`

Lassen Sie den Sandbox-Proxy TLS terminieren, damit er den Inhalt von HTTPS-Anfragen lesen kann. Dies ist experimentell, und die `mask`-[Ersetzung von Anmeldedaten](https://code.claude.com/docs/de/sandboxing.md#mask-credentials) erfordert es. Setzen Sie `{}`, um eine kurzlebige Zertifizierungsstelle für die Sitzung zu generieren, oder setzen Sie `caCertPath` und `caKeyPath`, um Ihre eigene zu verwenden.

* **Bereich**: [`User or managed`](#scopes). Ein Repository kann es weder einschalten noch eine Zertifizierungsstelle bereitstellen.
* **Typ**: Objekt mit optionalen Zeichenfolgen `caCertPath` und `caKeyPath`, jeweils ein Dateipfad
* **Standard**: nicht gesetzt, daher terminiert und prüft der Proxy TLS nicht

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "tlsTerminate": {}
    }
  }
}
```

Wenn mehr als eine berücksichtigte Quelle es setzt, verwendet Claude Code den Wert aus der Quelle mit der höchsten Priorität: verwaltete Einstellungen, dann das `--settings`-Flag, dann Benutzereinstellungen.

## Memory und Kontext

Steuern Sie, was Claude Code in den Kontext lädt, wie es komprimiert wird und wo es Memory und Pläne ablegt. Siehe [Kontext verwalten](https://code.claude.com/docs/de/context-window.md) und [Memory](https://code.claude.com/docs/de/memory.md).

### `autoCompactEnabled`

Lassen Sie Claude Code [die Konversation automatisch komprimieren](https://code.claude.com/docs/de/context-window.md#when-your-context-fills-up), wenn sich der Kontext dem Limit nähert. Erscheint in `/config` als **Auto-compact**, und das Umschalten dort schreibt diesen Schlüssel in Ihre Benutzereinstellungen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code komprimiert die Konversation automatisch, wenn sich der Kontext dem Limit nähert
  * `false`: Claude Code komprimiert nicht automatisch
* **Standard**: `true`
* **Überschreibungen pro Sitzung**: [`DISABLE_AUTO_COMPACT`](https://code.claude.com/docs/de/env-vars) deaktiviert die automatische Komprimierung für eine Sitzung; welcher der beiden sie auch deaktiviert, der andere kann sie nicht wieder aktivieren

```json settings.json theme={null}
{
  "autoCompactEnabled": false
}
```

Der manuelle `/compact`-Befehl funktioniert weiterhin, während die automatische Komprimierung deaktiviert ist. Wenn Sie die automatische Komprimierung deaktivieren, wird auch die [Komprimierung im Leerlauf](#idlecompaction) deaktiviert.

### `autoCompactWindow`

Legen Sie fest, wie voll das Kontextfenster wird, bevor Claude Code [automatisch komprimiert](https://code.claude.com/docs/de/context-window.md#when-your-context-fills-up).

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Anzahl der Token, von `100000` bis `1000000`. Claude Code begrenzt den Wert auf das Kontextfenster Ihres Modells; die [Modellübersicht](https://platform.claude.com/docs/en/about-claude/models/overview) listet das Fenster jedes Modells auf
* **Standard**: nicht gesetzt, daher wählt Claude Code ein für Ihr Modell optimiertes Fenster
* **Überschreibungen pro Sitzung**: [`--autocompact`](https://code.claude.com/docs/de/cli-reference#cli-flags) hat für eine Sitzung Vorrang vor diesem Schlüssel, und [`CLAUDE_CODE_AUTO_COMPACT_WINDOW`](https://code.claude.com/docs/de/env-vars) hat Vorrang vor beiden, es sei denn, Claude Code [ignoriert den Wert der Variable](https://code.claude.com/docs/de/model-config.md#claude_code_auto_compact_window-values)

```json settings.json theme={null}
{
  "autoCompactWindow": 500000
}
```

Der Befehl [`/autocompact`](https://code.claude.com/docs/de/commands#all-commands) speichert ein Fenster für das aktuelle Modell unter [`modelSettings`](#modelsettings), das für dieses Modell Vorrang vor diesem Schlüssel in derselben Datei hat. [Auto-Compact-Fenster einstellen](https://code.claude.com/docs/de/model-config.md#set-the-auto-compact-window) behandelt, wie der Befehl, das Flag, die Variable und die Einstellung zusammenwirken.

### `autoMemoryDirectory`

Speichern Sie [Auto-Memory](https://code.claude.com/docs/de/memory.md#storage-location) in einem Verzeichnis Ihrer Wahl statt im projektspezifischen Standardverzeichnis.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, ein absoluter oder mit `~/` präfixierter Verzeichnispfad
* **Standard**: nicht gesetzt, daher verwendet Claude Code `~/.claude/projects/<project>/memory/`

```json settings.json theme={null}
{
  "autoMemoryDirectory": "~/my-memory-dir"
}
```

Aus Projekt- oder lokalen Einstellungen respektiert Claude Code diesen Schlüssel unter der gleichen [Workspace-Vertrauensregel wie Hooks](https://code.claude.com/docs/de/permissions.md#what-runs-before-you-trust-a-folder), da ein geklontes Repository diese Dateien bereitstellen kann.

### `autoMemoryEnabled`

Schalten Sie [Auto-Memory](https://code.claude.com/docs/de/memory.md#enable-or-disable-auto-memory) ein oder aus. Wenn `false`, liest Claude nicht aus dem Auto-Memory-Verzeichnis und schreibt nicht dorthin. Sie können es auch während einer Sitzung mit `/memory` umschalten, was diesen Schlüssel in Ihre Benutzereinstellungen schreibt.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: dasselbe wie nicht gesetzt; Auto-Memory bleibt aktiviert, es sei denn, etwas, das Vorrang vor diesem Schlüssel hat, deaktiviert es für die Sitzung, wie `--bare`, der sichere Modus oder `CLAUDE_CODE_DISABLE_AUTO_MEMORY`
  * `false`: Claude liest nicht aus dem Auto-Memory-Verzeichnis und schreibt nicht dorthin
* **Standard**: `true`
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](https://code.claude.com/docs/de/env-vars) hat für eine Sitzung Vorrang vor diesem Schlüssel, in beide Richtungen

```json settings.json theme={null}
{
  "autoMemoryEnabled": false
}
```

### `bashOutputMaxChars`

Legen Sie fest, wie viele Zeichen der [Ausgabe eines erfolgreichen Bash- oder PowerShell-Befehls Claude inline erhält](https://code.claude.com/docs/de/tools-reference.md#output-limits). Wenn die Ausgabe das Limit überschreitet, speichert Claude Code sie in einer Datei und Claude erhält eine kurze Vorschau plus den Pfad der Datei. Erhöhen Sie das Limit, wenn die Befehlsausgabe, wie ein ausführlicher Build oder ein vollständiges Test-Suite-Log, routinemäßig das Standardlimit überschreitet und Sie möchten, dass Claude sie liest, ohne die Datei zu öffnen. Erfordert Claude Code v2.1.261 oder später.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Anzahl der Zeichen, eine positive ganze Zahl. Claude Code begrenzt den Wert auf den Bereich `4000` bis `128000`
* **Standard**: nicht gesetzt, daher erhält Claude bis zu 30.000 Zeichen inline

```json settings.json theme={null}
{
  "bashOutputMaxChars": 100000
}
```

Wenn Sie diesen Schlüssel setzen, ignoriert Claude Code die Umgebungsvariable [`BASH_MAX_OUTPUT_LENGTH`](https://code.claude.com/docs/de/env-vars).

### `claudeMd`

Fügen Sie CLAUDE.md-ähnliche Anweisungen als von der Organisation verwaltetes Memory ein, ohne eine separate Datei bereitzustellen. Claude Code lädt den Text als verwalteten Memory-Eintrag vor Benutzer- und Projekt-CLAUDE.md-Dateien.

* **Geltungsbereich**: [`Managed`](#scopes)
* **Typ**: String, der Text einer CLAUDE.md-Datei; schreiben Sie ihn wie die Datei, Markdown eingeschlossen, mit Zeilenumbrüchen als `\n`
* **Standard**: nicht gesetzt

Dieses Beispiel stellt zwei Regeln als kurze Markdown-Liste bereit:

```json managed-settings.json theme={null}
{
  "claudeMd": "# Engineering rules\n\n- Always run make lint before committing.\n- Never push directly to main."
}
```

Siehe [Organisationsweite CLAUDE.md bereitstellen](https://code.claude.com/docs/de/memory.md#deploy-organization-wide-claude-md).

### `claudeMdExcludes`

Überspringen Sie bestimmte `CLAUDE.md`-Dateien, wenn Claude Code [Memory](https://code.claude.com/docs/de/memory.md#exclude-specific-claude-md-files) lädt. In einem großen Monorepo verwenden Sie es, um CLAUDE.md-Dateien anderer Teams zu überspringen, die für Ihre Arbeit nicht relevant sind; [Irrelevante CLAUDE.md-Dateien ausschließen](https://code.claude.com/docs/de/large-codebases.md#exclude-irrelevant-claude-md-files) im Leitfaden für große Codebases führt Sie durch diesen Fall. Muster werden gegen absolute Dateipfade abgeglichen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Array von Strings, jeweils ein Glob-Muster oder absoluter Pfad
* **Standard**: nicht gesetzt, daher lädt Claude Code jede CLAUDE.md, die es findet

```json settings.json theme={null}
{
  "claudeMdExcludes": ["**/vendor/**/CLAUDE.md"]
}
```

Ausschlüsse gelten nur für Benutzer-, Projekt- und lokale Memory-Dateien; CLAUDE.md-Dateien aus verwalteten Richtlinien können nicht ausgeschlossen werden.

### `env`

Legen Sie Umgebungsvariablen für jede Sitzung und für die Unterprozesse fest, die Claude Code von ihr aus startet. Die meisten Variablen in der [Referenz der Umgebungsvariablen](https://code.claude.com/docs/de/env-vars.md) können hier eingetragen werden; so wenden Sie eine Variable auf jede Sitzung an oder verteilen sie an Ihr Team. Projekt- und lokale Einstellungen können [einige davon](#variables-claude-code-ignores-in-env) nicht setzen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Objekt, das Variablennamen auf String-Werte abbildet
* **Standard**: nicht gesetzt

Dieses Beispiel deaktiviert die automatische Komprimierung und leitet API-Anfragen über einen Proxy:

```json settings.json theme={null}
{
  "env": {
    "DISABLE_AUTO_COMPACT": "1",
    "ANTHROPIC_BASE_URL": "https://proxy.example.com"
  }
}
```

#### Wie `env`-Werte mit Ihrer Shell interagieren

* Ein Wert hier überschreibt dieselbe Variable, die in Ihrer Shell exportiert wird, und wenn mehr als eine Einstellungsdatei eine Variable setzt, gilt die mit dem [höchsten Vorrang](https://code.claude.com/docs/de/settings.md#settings-precedence). [Variablen, die Claude Code in `env` ignoriert](#variables-claude-code-ignores-in-env) listet die Ausnahmen für Projekt- und lokale Einstellungen auf.
* Wenn die Claude Desktop-App oder ein Runner einer [selbst gehosteten Umgebung](https://code.claude.com/docs/de/self-hosted-environments) die Sitzung startet, hat stattdessen die von ihr bzw. ihm erstellte Start-Umgebung Vorrang: Claude Code ignoriert einen `env`-Wert aus jeder Einstellungsdatei für eine Variable, die die Start-Umgebung bereits setzt. Das [Debug-Log](https://code.claude.com/docs/de/debug-your-config.md) nennt jede ignorierte Variable.
* Um einen Shell-Export aufzuheben, setzen Sie die Variable auf `""`. Claude Code behandelt einen leeren Wert bei der Anbieterauswahl als nicht gesetzt, und Unterprozesse erben den leeren Wert.
* `NO_COLOR` und `FORCE_COLOR`, die hier gesetzt sind, erreichen nur Unterprozesse. Um die Farben der Claude Code-Oberfläche selbst zu ändern, setzen Sie sie in Ihrer Shell, bevor Sie `claude` starten.
* Werte hier stehen im Klartext in der Einstellungsdatei und erreichen jeden Unterprozess, den Claude Code startet. Für ein OTLP-Bearer-Token, das rotiert wird, verwenden Sie [`otelHeadersHelper`](#otelheadershelper); für API-Anmeldedaten verwenden Sie [`apiKeyHelper`](#apikeyhelper).

#### Wann Claude Code `env`-Werte anwendet

* Aus Benutzereinstellungen, `--settings` und verwalteten Einstellungen: beim Start und erneut in der laufenden Sitzung, wenn eine gespeicherte Änderung die zusammengeführte `env` ändert.
* Aus Projekt- und lokalen Einstellungen: nachdem Sie dem Workspace vertrauen, oder beim Start im `-p`-Modus, der niemals den Vertrauensdialog anzeigt, und erneut, wenn eine gespeicherte Änderung die zusammengeführte `env` ändert.
* Variablen, die Claude Code als sicher einstuft, wie Modellauswahl, Timeouts und Limits sowie Feature-Toggles: beim Start aus jeder Einstellungsdatei, außer den [Variablen, die Projekt- und lokale Einstellungen nicht setzen können](#variables-claude-code-ignores-in-env).
* Nachdem Sie die [Sitzung mit `/cd` verschoben haben](https://code.claude.com/docs/de/permissions#move-the-session-to-another-directory), ab v2.1.246: die Projekt- und lokalen `env`-Werte des neuen Verzeichnisses, zusätzlich zu denen des vorherigen Verzeichnisses.

#### Variablen, die Claude Code in `env` ignoriert

* Projekt- und lokale Einstellungen können keine Variablen setzen, die ein ausgechecktes Repository nicht steuern sollte; setzen Sie diese stattdessen in Ihrer Shell, in Benutzereinstellungen oder in verwalteten Einstellungen. Claude Code verwirft jede davon, außer einigen Werten, die Telemetrie ausschalten, und protokolliert eine Warnung, die Sie mit `claude --debug` sehen können. Dazu gehören:

  * Variablen, die festlegen, wo Claude Code seine eigenen Dateien speichert oder schreibt: `CLAUDE_CONFIG_DIR`, `CLAUDE_CODE_TMPDIR` und die Verzeichnisvariablen des Betriebssystems wie `HOME`, `TMPDIR`, `TMP`, `TEMP` und die `XDG_*`-Familie.
  * Windows-Variablen, die die Programme und die rechnerweite Konfiguration für die Prozesse festlegen, die Claude Code startet, wie `SystemRoot`, `ComSpec`, `ProgramData`, `LOCALAPPDATA`, `PATHEXT`, `PSModulePath` und die `ProgramFiles`-Familie.
  * Variablen, die Sitzungsinhalte exportieren: [`OTEL_LOG_RAW_API_BODIES`](https://code.claude.com/docs/de/env-vars#variables) und das detaillierte Beta-Tracing-Paar `ENABLE_BETA_TRACING_DETAILED` und `BETA_TRACING_ENDPOINT`.
  * Die Variablen des [OpenTelemetry-Exporters](https://code.claude.com/docs/de/monitoring-usage.md), die Telemetrie aktivieren, festlegen, wohin sie gesendet wird, oder festlegen, welche Inhalte sie erfasst:

    * `CLAUDE_CODE_ENABLE_TELEMETRY`, plus das Beta-Paar für erweiterte Telemetrie `CLAUDE_CODE_ENHANCED_TELEMETRY_BETA` und `ENABLE_ENHANCED_TELEMETRY_BETA`
    * Die Exporter-Selektoren `OTEL_LOGS_EXPORTER`, `OTEL_METRICS_EXPORTER` und `OTEL_TRACES_EXPORTER`
    * Die Inhaltsvariablen `OTEL_LOG_USER_PROMPTS`, `OTEL_LOG_ASSISTANT_RESPONSES`, `OTEL_LOG_TOOL_CONTENT` und `OTEL_LOG_TOOL_DETAILS`
    * `OTEL_EXPORTER_OTLP_*`-Variablen, deren Namen auf `_ENDPOINT`, `_HEADERS`, `_PROTOCOL`, `_CERTIFICATE`, `_CLIENT_KEY` oder `_INSECURE` enden, in der generischen und der signalspezifischen Form, wie `OTEL_EXPORTER_OTLP_ENDPOINT` und `OTEL_EXPORTER_OTLP_METRICS_HEADERS`
    * `OTEL_EXPORTER_PROMETHEUS_HOST` und `OTEL_EXPORTER_PROMETHEUS_PORT`

    Nur diese Werte gelten weiterhin aus Projekt- und lokalen Einstellungen, da sie etwas ausschalten: `none` für die drei Exporter-Selektoren und ein Aus-Wert wie `0` für `OTEL_LOG_USER_PROMPTS`, `OTEL_LOG_TOOL_CONTENT` und `OTEL_LOG_TOOL_DETAILS`. Ein solcher Wert überschreibt dieselbe Variable in Ihren Benutzereinstellungen, aber nicht eine, die die Umgebung, aus der Sie Claude Code starten, eine `--settings`-Datei oder verwaltete Einstellungen setzen.

    Wenn eine Projekt- oder lokale Einstellungsdatei eine Variable aus dieser Gruppe setzt, zeigt eine lokale interaktive Sitzung beim Start einen Hinweis. Führen Sie `/status` oder `claude doctor` aus, um zu sehen, welche Claude Code ignoriert hat und welche die Telemetrie ausgeschaltet haben; beide listen Namen auf, niemals Werte. Ein nicht interaktiver Lauf mit `-p` oder eine Agent SDK-Sitzung zeigt keinen Hinweis, überprüfen Sie daher nach dem Upgrade, ob Ihr Collector noch Daten empfängt. Wenn nicht, setzen Sie die Variablen in Ihren Benutzereinstellungen, in verwalteten Einstellungen, in der Umgebung des Jobs oder in einer Datei, die Sie mit `--settings` übergeben.

    Das Ignorieren dieser Gruppe in Projekt- und lokalen Einstellungen erfordert Claude Code v2.1.282 oder später.
  * Variablen, die ändern, wie Claude Code startet oder synchronisiert, wie `CLAUDE_CODE_PROCESS_WRAPPER`, `CLAUDE_CODE_SYNC_SKILLS`, `CLAUDE_CODE_SYNC_PLUGINS`, `CLAUDE_CODE_PLUGIN_CACHE_DIR` und `CLAUDE_CODE_PLUGIN_SEED_DIR`.
  * Die Variable `CLAUDE_AX_SCREEN_READER` für den [Screenreader-Modus](https://code.claude.com/docs/de/accessibility.md) und die anderen Variablen, deren Namen mit `CLAUDE_AX_` beginnen, wie [`CLAUDE_AX_STARTUP_QUIET_MS`](https://code.claude.com/docs/de/env-vars#variables).
  * [`CLAUDE_CODE_USER_DIALOG_TIMEOUT_MS`](https://code.claude.com/docs/de/env-vars#variables), das den Timer für einen unbeantworteten Dialog festlegt.
  * [`CLAUDE_CODE_DISABLE_ATTACHMENTS`](https://code.claude.com/docs/de/env-vars#variables), das die Verarbeitung von Anhängen ausschaltet.
  * [`CLAUDE_CODE_DISABLE_FILE_MENTIONS`](https://code.claude.com/docs/de/env-vars#variables), das verhindert, dass Claude Code `@`-Erwähnungen von Dateien und Verzeichnissen auflöst.

  Vor v2.1.251 konnten Projekt- und lokale Einstellungen auch die Variablen in dieser Liste setzen, die festlegen, wo Claude Code seine Dateien schreibt, oder die Sitzungsinhalte exportieren, außer `HOME` und `XDG_CONFIG_HOME`. Vor v2.1.290 konnten sie auch die Variablen für die Dialog-Timer und `CLAUDE_CODE_DISABLE_ATTACHMENTS` setzen.
* Identitätsvariablen, die den Hosting-Umgebungen von Claude Code gehören, wie `CLAUDE_CODE_REMOTE` und `CLAUDE_CODE_ACCOUNT_UUID`, werden aus jeder Datei ignoriert.
* [`CLAUDE_CODE_MESSAGING_SOCKET` und `CLAUDE_CODE_MESSAGING_TOKEN`](https://code.claude.com/docs/de/env-vars#variables), die Claude Code selbst exportiert, werden aus jeder Datei ignoriert. Das Ignorieren der Socket-Variable erfordert Claude Code v2.1.224 oder später, und das Ignorieren des Tokens erfordert v2.1.228 oder später.
* [`CLAUDE_CODE_PROJECT_DIR_NAME`](https://code.claude.com/docs/de/sessions#name-the-project-directory-yourself), das Claude Code nur aus der Start-Umgebung liest, wird aus jeder Datei ignoriert; erfordert v2.1.234 oder später.
* [`CLAUDE_CODE_RESTRICTED`](https://code.claude.com/docs/de/env-vars#variables), das Claude Code nur aus der Start-Umgebung liest, wird aus jeder Datei ignoriert.
* [`CLAUDE_CODE_DISABLE_POWERSHELL_CMD_RM_DENY`](https://code.claude.com/docs/de/env-vars#variables), das Claude Code nur aus der Start-Umgebung liest, wird aus jeder Datei ignoriert. Die Variable erfordert Claude Code v2.1.283 oder später.
* [`CLAUDE_CODE_DISABLE_DANGEROUS_RM_TIMEOUT`, `CLAUDE_CODE_DISABLE_SUBSTITUTION_RM_PROMPT`, `CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT` und `CLAUDE_CODE_DISABLE_MOUNTED_DRIVE_RM_PROMPT`](https://code.claude.com/docs/de/env-vars#variables), die Claude Code nur aus der Start-Umgebung liest, werden aus jeder Datei ignoriert.
* [`CLAUDE_CODE_WARN_DISK_FREE_GIB` und `CLAUDE_CODE_WARN_MEMORY_FREE_GIB`](https://code.claude.com/docs/de/env-vars#variables), die Claude Code nur aus der Start-Umgebung liest, werden aus jeder Datei ignoriert. Die Variablen erfordern Claude Code v2.1.304 oder später.

### `fileCheckpointingEnabled`

Lassen Sie Claude Code vor jeder Bearbeitung Snapshots von Dateien erstellen, damit [`/rewind`](https://code.claude.com/docs/de/checkpointing) sie wiederherstellen kann. Erscheint in `/config` als **Rewind code (checkpoints)**, und das Umschalten dort schreibt diesen Schlüssel in Ihre Benutzereinstellungen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code erstellt vor jeder Bearbeitung Snapshots von Dateien, damit `/rewind` sie wiederherstellen kann
  * `false`: Claude Code erstellt keine Snapshots von Dateien, daher kann `/rewind` sie nicht wiederherstellen
* **Standard**: `true`
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING`](https://code.claude.com/docs/de/env-vars) deaktiviert Checkpointing für eine Sitzung; welcher der beiden es auch deaktiviert, der andere kann es nicht wieder aktivieren

```json settings.json theme={null}
{
  "fileCheckpointingEnabled": false
}
```

In einem `-p`-Lauf oder einer Agent SDK-Sitzung ignoriert Claude Code diesen Schlüssel. Das SDK aktiviert Checkpointing mit seiner Option `enableFileCheckpointing`, und ein einfacher `-p`-Lauf benötigt `CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING=true`. Siehe [Datei-Checkpointing im Agent SDK](https://code.claude.com/docs/de/agent-sdk/file-checkpointing.md).

### `idleCompaction`

Die Komprimierung im Leerlauf [komprimiert](https://code.claude.com/docs/de/context-window.md#what-survives-compaction) eine lange Konversation, von der Sie sich entfernt haben. Ihre nächste Nachricht sendet dann eine Zusammenfassung statt der gesamten Konversation. Nach der Komprimierung zeigt die Konversation einen Hinweis an:

* **Terminal**: eine Zeile, die mit `Compacted while idle, before the prompt cache expired` beginnt
* **[VS Code-Chatbereich](#idle-compaction-in-vs-code-and-the-desktop-app)**: ein Hinweis, der `a summary written while you were away` enthält
* **[Desktop-App](#idle-compaction-in-vs-code-and-the-desktop-app)**: derselbe Hinweis, innerhalb einer Zeile, deren Beschriftung `Claude Code notice` enthält. Wenn Sie diese Zeile oder ihren Text nicht sehen, wechseln Sie in den [Ansichtsmodus Verbose](https://code.claude.com/docs/de/desktop.md#switch-view-modes).

Die Komprimierung im Leerlauf ist standardmäßig für Konversationen aktiviert, die alle diese Bedingungen erfüllen:

* **Sitzung**: Sie befinden sich in einer interaktiven Terminal-Sitzung oder im Chatbereich der VS Code-Erweiterung bzw. im Code-Tab der Desktop-App mit einem [Konto, das Anthropic auswählt](#idle-compaction-in-vs-code-and-the-desktop-app)
* **Automatische Komprimierung**: [`autoCompactEnabled`](#autocompactenabled) ist aktiviert
* **Prompt-Cache**: Die Konversation verwendet die [einstündige Prompt-Cache-TTL](https://code.claude.com/docs/de/prompt-caching.md#which-ttl-each-request-gets)
* **Feature-Flags**: Claude Code kann [Feature-Flags von Anthropic abrufen](https://code.claude.com/docs/de/env-vars.md#features-that-need-feature-flag-fetching)
* **Größe**: Der Kontext der Konversation hat den Token-Schwellenwert erreicht, den Sie gegenüber seinem Standardwert von 200.000 [ändern](#change-the-idle-compaction-threshold) können
* **Leerlaufzeit**: Seit der letzten Anfrage sind etwa 54 Minuten vergangen, und Ihr Computer befindet sich zu diesem Zeitpunkt nicht im Ruhezustand

Um die Komprimierung im Leerlauf auszuschalten, setzen Sie diesen Schlüssel auf `false`.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code komprimiert Konversationen im Leerlauf, die die Bedingungen erfüllen
  * `false`: Claude Code komprimiert nicht, während sich Ihre Sitzung im Leerlauf befindet
* **Standard**: `true`
* **Überschreibungen pro Sitzung**: [`DISABLE_AUTO_COMPACT`](https://code.claude.com/docs/de/env-vars) deaktiviert die Komprimierung im Leerlauf zusammen mit der automatischen Komprimierung

```json settings.json theme={null}
{
  "idleCompaction": false
}
```

Um die Komprimierung im Leerlauf innerhalb einer Terminal-Sitzung aus- oder einzuschalten, führen Sie `/config` aus und ändern Sie die Zeile **Idle compaction**. Ihre Auswahl wird in Ihren Benutzereinstellungen gespeichert und gilt sofort. Die Zeile erfordert Claude Code v2.1.302 oder später. Wenn Sie eine dieser Versionen verwenden und `/config` die Zeile nicht anzeigt, prüfen Sie diese Ursachen:

* **Eine andere Einstellungsquelle setzt den Schlüssel**: Ein Wert in verwalteten Einstellungen, im Flag `--settings` oder in einer Projekt- oder lokalen Einstellungsdatei überschreibt Ihre Benutzereinstellungen. Ändern Sie den Schlüssel stattdessen in dieser Quelle
* **Feature-Flags sind nicht verfügbar**: Wo Claude Code keine [Feature-Flags von Anthropic abrufen](https://code.claude.com/docs/de/env-vars.md#features-that-need-feature-flag-fetching) kann, wird die Komprimierung im Leerlauf nicht ausgeführt, daher gibt es nichts auszuschalten

Der Schlüssel erfordert Claude Code v2.1.290 oder später. In einer früheren Version, die diesen Schlüssel ignoriert, deaktivieren Sie [`autoCompactEnabled`](#autocompactenabled), um die Komprimierung im Leerlauf zu stoppen.

#### Schwellenwert für die Komprimierung im Leerlauf ändern

Setzen Sie [`CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS`](https://code.claude.com/docs/de/env-vars) auf die Anzahl der Token, die der Kontext einer Konversation erreichen muss, bevor die Komprimierung im Leerlauf für sie gilt. Verwenden Sie eine positive ganze Zahl. Werte unter `100000` werden auf `100000` angehoben, den niedrigsten Schwellenwert.

Beim Standardwert wird eine Konversation mit einem Kontextfenster von 200K automatisch komprimiert, bevor sie 200.000 Token erreicht. Dieses Beispiel senkt den Schwellenwert auf 150.000, sodass diese Konversationen infrage kommen:

```json settings.json theme={null}
{
  "env": {
    "CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS": "150000"
  }
}
```

#### Komprimierung im Leerlauf in VS Code und der Desktop-App

Ein Hinweis wie dieser bedeutet, dass Claude Code [Ihre bisherige Konversation durch eine Zusammenfassung ersetzt hat](https://code.claude.com/docs/de/context-window.md#what-survives-compaction), mit der Claude nun weiterarbeitet:

```text theme={null}
Compacted using a summary written while you were away · turn off with "idleCompaction": false in settings.json
```

Sie müssen nichts tun. Um die Komprimierung im Leerlauf auszuschalten, setzen Sie `idleCompaction` in `~/.claude/settings.json` oder einer anderen [Einstellungsdatei](https://code.claude.com/docs/de/settings.md#settings-files-and-who-they-affect) auf `false`.

Im Chatbereich der VS Code-Erweiterung und im Code-Tab der Desktop-App wird die Komprimierung im Leerlauf für Konten ausgeführt, die Anthropic auswählt. Claude Code schreibt die Zusammenfassung, während Sie abwesend sind, und komprimiert damit nur, wenn Ihre nächste Nachricht eine Stunde oder länger nach der letzten Anfrage eintrifft.

### `plansDirectory`

Wählen Sie, wo Claude Code die Plandateien speichert, die es im [Plan-Modus](https://code.claude.com/docs/de/permission-modes.md#analyze-before-you-edit-with-plan-mode) schreibt. Claude Code löst den Pfad relativ zum Projektstamm auf.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, ein Pfad relativ zum Projektstamm
* **Standard**: nicht gesetzt, daher verwendet Claude Code `~/.claude/plans`

```json settings.json theme={null}
{
  "plansDirectory": "./plans"
}
```

In Fällen wie diesen speichert Claude Code Pläne in `~/.claude/plans` statt in dem von Ihnen festgelegten Verzeichnis:

* **Außerhalb des Projektstamms**: Der Pfad wird außerhalb des Projektstamms aufgelöst, wie bei `"../plans"`.
* **Backslash unter macOS, Linux und WSL**: Der aufgelöste Pfad enthält einen Backslash, wie bei `"docs\\plans"` im Windows-Stil. Schreiben Sie `"docs/plans"`, was auch unter Windows funktioniert.

### `skillListingBudgetFraction`

In jedem Turn sieht Claude eine [Auflistung Ihrer Skills](https://code.claude.com/docs/de/skills.md#skill-descriptions-are-cut-short) mit ihren Beschreibungen, und Claude Code begrenzt diese Auflistung auf einen Anteil des Kontextfensters. Wenn die Auflistung die Obergrenze überschreitet, behält Claude Code den Namen jedes Skills bei, entfernt aber die Beschreibungen der am wenigsten verwendeten Skills, sodass Claude diese Skills weiterhin aufrufen kann, aber seltener von sich aus einen davon auswählt. Erhöhen Sie diesen Schlüssel, um mehr Beschreibungen sichtbar zu halten, auf Kosten von mehr Kontext pro Turn.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Zahl, ein Bruchteil größer als `0` und höchstens `1`
* **Standard**: `0.01`, was 1 % des Kontextfensters reserviert

```json settings.json theme={null}
{
  "skillListingBudgetFraction": 0.02
}
```

Um zu sehen, wie viel Kontext die Auflistung verwendet und welche Skills am meisten beitragen, führen Sie `/doctor` aus.

### `skillListingMaxDescChars`

In jedem Turn sieht Claude eine [Auflistung Ihrer Skills](https://code.claude.com/docs/de/skills.md#skill-descriptions-are-cut-short), die den `description`- und `when_to_use`-Text jedes Skills zeigt. Dieser Schlüssel begrenzt, wie viele Zeichen dieses Textes Claude Code pro Skill anzeigt; längerer Text wird an der Obergrenze abgeschnitten.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Anzahl der Zeichen, eine positive ganze Zahl
* **Standard**: `1536`

```json settings.json theme={null}
{
  "skillListingMaxDescChars": 2048
}
```

Erhöhen Sie den Wert, um lange Beschreibungen vollständig zu erhalten, auf Kosten von mehr Kontext pro Turn; senken Sie ihn, um mehr Skills innerhalb von [`skillListingBudgetFraction`](#skilllistingbudgetfraction) unterzubringen.

### `taskOutputMaxChars`

> [!WARNING]
>
> Entfernt in v2.1.277, zusammen mit dem `TaskOutput`-Tool, dessen Ausgabegröße es festlegte. Das Setzen hat in aktuellen Versionen keine Auswirkung. Claude liest die [Ausgabedatei](https://code.claude.com/docs/de/tools-reference.md#background-commands) einer Hintergrundaufgabe stattdessen mit `Read`.

Bis v2.1.276 legten Sie mit diesem Schlüssel die Anzahl der Zeichen der Ausgabe einer [Hintergrundaufgabe](https://code.claude.com/docs/de/tools-reference.md#background-commands) fest, die Claude inline erhielt, wenn es die Aufgabe mit dem `TaskOutput`-Tool las.

## Oberfläche und Terminal

Ändern Sie, wie Claude Code in Ihrem Terminal aussieht und sich verhält: Theme, Editor-Modus, Statuszeile, Spinner, Benachrichtigungen innerhalb der Sitzung und Barrierefreiheit. Siehe [Terminal-Konfiguration](https://code.claude.com/docs/de/terminal-config.md).

### `askUserQuestionTimeout`

Lassen Sie einen unbeantworteten [`AskUserQuestion`](https://code.claude.com/docs/de/tools-reference)-Dialog nach einer Leerlaufzeit automatisch fortfahren, wobei die bereits ausgewählten Optionen übermittelt werden. Setzen Sie diesen Schlüssel, wenn Sie sich entfernen und möchten, dass Claude ohne Sie weiterarbeitet. Mit dem Standardwert warten Fragen, bis Sie sie beantworten. Wann der Timer pausiert oder gar nicht erst startet, erfahren Sie unter [Timeout für automatisches Fortfahren bei Fragen](https://code.claude.com/docs/de/tools-reference.md#question-auto-continue-timeout).

* **Geltungsbereich**: [`User or managed`](#scopes)
* **Typ**: String, einer von `"60s"`, `"5m"`, `"10m"` oder `"never"`
* **Standard**: `"never"`

```json settings.json theme={null}
{
  "askUserQuestionTimeout": "5m"
}
```

Erscheint in `/config` als **Question auto-continue timeout**, das diesen Schlüssel in die Benutzereinstellungen schreibt; Claude Code blendet die Zeile aus, solange verwaltete Einstellungen oder das Flag `--settings` den Schlüssel setzen.

### `autoContinueAtUsageLimit`

Nachdem ein claude.ai-Nutzungslimit Ihre Sitzung angehalten hat, in der geöffneten Sitzung warten und die Aufgabe nach dem Zurücksetzen automatisch fortsetzen. Siehe [Automatisches Fortsetzen ausschalten](https://code.claude.com/docs/de/interactive-mode.md#turn-automatic-continue-off). Erfordert Claude Code v2.1.234 oder höher.

* **Geltungsbereich**: [`User or managed`](#scopes). Wird nur aus den Benutzereinstellungen, `--settings` und verwalteten Einstellungen gelesen. Wenn keine davon den Schlüssel setzt, schaltet eine Projekt- oder lokale Einstellungsdatei, die ihn setzt, die Funktion aus, statt ignoriert zu werden.
* **Typ**: Boolean
  * `true`: Nachdem ein claude.ai-Nutzungslimit Ihre Sitzung angehalten hat, wartet Claude Code in der geöffneten Sitzung und setzt die Aufgabe nach dem Zurücksetzen automatisch fort
  * `false`: Claude Code startet das Warten nicht von selbst. Sie können [das Warten weiterhin selbst starten](https://code.claude.com/docs/de/interactive-mode.md#start-a-wait-yourself), und zwar über das Optionsmenü für Nutzungslimits
* **Standard**: `true`

```json settings.json theme={null}
{
  "autoContinueAtUsageLimit": false
}
```

Erscheint in `/config` als **Continue automatically at usage limit**, das diesen Schlüssel in die Benutzereinstellungen schreibt; Claude Code blendet die Zeile aus, solange verwaltete Einstellungen oder das Flag `--settings` den Schlüssel setzen.

### `autoScrollEnabled`

Neuer Ausgabe bis zum Ende der Konversation folgen, im [Vollbild-Rendering](https://code.claude.com/docs/de/fullscreen.md). Schalten Sie es aus, um an der Stelle zu bleiben, zu der Sie gescrollt haben, während Claude weiterarbeitet; Berechtigungsabfragen werden weiterhin in den sichtbaren Bereich gescrollt.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Die Konversation folgt neuer Ausgabe bis zum Ende
  * `false`: Sie bleiben an der Stelle, zu der Sie gescrollt haben, während Claude weiterarbeitet; Berechtigungsabfragen erscheinen weiterhin unterhalb des Transkripts
* **Standard**: `true`

```json settings.json theme={null}
{
  "autoScrollEnabled": false
}
```

Erscheint in `/config` als **Auto-scroll**, wenn das Vollbild-Rendering aktiv ist, und schreibt diesen Schlüssel in die Benutzereinstellungen.

### `axScreenReader`

Screenreader-freundliche Ausgabe rendern: einfacher Text ohne dekorative Rahmen oder Animationen. Der Screenreader-Modus verwendet den klassischen Renderer, daher hat die Einstellung `tui` keine Wirkung, solange er aktiv ist; angehängte [Hintergrundsitzungen](https://code.claude.com/docs/de/agent-view.md) werden weiterhin im Vollbild gerendert.

* **Geltungsbereich**: [`User or managed`](#scopes). Sie können den Schlüssel auch in einer Datei setzen, die Sie mit `--settings` übergeben. Claude Code ignoriert den Schlüssel in Projekt- und lokalen Einstellungen, daher kann weder ein Repository noch Ihre eigene `.claude/settings.local.json` den Screenreader-Modus ein- oder ausschalten.
* **Typ**: Boolean
  * `true`: Claude Code rendert einfachen Text ohne dekorative Rahmen oder Animationen und verwendet den klassischen Renderer
  * `false`: Claude Code rendert normal
* **Standard**: nicht gesetzt, daher ist der Screenreader-Modus aus
* **Überschreibungen pro Sitzung**: [`--ax-screen-reader`](https://code.claude.com/docs/de/cli-reference#cli-flags) hat Vorrang vor [`CLAUDE_AX_SCREEN_READER`](https://code.claude.com/docs/de/env-vars), und beide haben für eine Sitzung Vorrang vor diesem Schlüssel

```json settings.json theme={null}
{
  "axScreenReader": true
}
```

### `bashEditDiffEnabled`

Legen Sie fest, ob Claude Code aufzeichnet, welche Dateien sich in einem Git-Repository geändert haben, während ein Bash-Befehl läuft. Wenn es sie aufzeichnet, sehen Sie nach dem Befehl deren Diff im Terminal, und Ihre [PostToolUse-Bash-Hooks](https://code.claude.com/docs/de/hooks.md#bash) erhalten die Liste der geänderten Dateien.

Eine aufgeführte Datei ist nicht immer eine, die der Befehl geändert hat. Auch eine Änderung, die ein anderes Programm oder ein anderer Bash-Aufruf vorgenommen hat, während der Befehl lief, kann dort erscheinen.

Setzen Sie den Schlüssel auf `true`, um sie in jedem Berechtigungsmodus aufzuzeichnen. Erfordert Claude Code v2.1.269 oder höher.

* **Geltungsbereich**: [`User or managed`](#scopes). Ein `true` zählt nur aus Ihren Benutzereinstellungen, aus mit `--settings` übergebenem JSON oder aus [verwalteten Einstellungen](https://code.claude.com/docs/de/managed-settings.md), daher kann ein `true` in der `.claude/settings.json` oder `.claude/settings.local.json` eines Repositorys die Aufzeichnung nicht einschalten. Ein `false` in einer der beiden Repository-Dateien schaltet sie dennoch aus, es sei denn, eine Datei mit [höherem Vorrang](https://code.claude.com/docs/de/settings.md#settings-precedence) setzt `true`.
* **Typ**: Boolean
* **Standard**: nicht gesetzt, daher zeichnet Claude Code Änderungen im Auto-Modus und im Modus `bypassPermissions` auf, wenn es Claude anweist, Dateien über Bash zu bearbeiten
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_BASH_EDIT_DIFF`](https://code.claude.com/docs/de/env-vars) hat für eine Sitzung Vorrang vor diesem Schlüssel

```json settings.json theme={null}
{
  "bashEditDiffEnabled": true
}
```

### `companyAnnouncements`

Den Benutzern beim Start die Ankündigungen Ihrer Organisation anzeigen. Wenn Sie mehr als eine auflisten, wählt Claude Code für jede Sitzung eine zufällig aus; beim allerersten Start einer Person zeigt es den ersten Eintrag.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Array von Strings
* **Standard**: nicht gesetzt, daher wird keine Ankündigung angezeigt

```json settings.json theme={null}
{
  "companyAnnouncements": [
    "Welcome to Acme Corp! Review our code guidelines at docs.example.com"
  ]
}
```

### `defaultShell`

Legen Sie fest, ob Bash oder PowerShell die Shell-Befehle ausführt, die Sie mit dem [`!`-Präfix](https://code.claude.com/docs/de/interactive-mode#shell-mode-with-prefix) in das Eingabefeld eingeben, also die Befehle, die Claude Code direkt ausführt und der Sitzung hinzufügt.

`"powershell"` funktioniert nur, solange das [PowerShell-Tool](https://code.claude.com/docs/de/tools-reference.md#powershell-tool) eingeschaltet ist. Das Tool ist standardmäßig unter Windows ohne Git Bash eingeschaltet sowie unter Windows mit Git Bash für claude.ai- und Console-Konten. In Sitzungen mit Amazon Bedrock, Google Clouds Agent Platform und Microsoft Foundry sowie unter macOS, Linux und WSL setzen Sie `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`, um das Tool einzuschalten. Setzen Sie diese Variable auf `0`, um das Tool auszuschalten.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, einer von:
  * `"bash"`: Claude Code führt Ihre `!`-Befehle in Bash aus
  * `"powershell"`: Claude Code führt Ihre `!`-Befehle in PowerShell aus
* **Standard**: `"bash"`, oder `"powershell"` unter Windows, wenn Bash nicht verfügbar ist

```json settings.json theme={null}
{
  "defaultShell": "powershell"
}
```

Wenn die angegebene Shell nicht verfügbar ist, verwendet Claude Code die jeweils andere: `"powershell"` fällt auf Bash zurück, wenn das PowerShell-Tool ausgeschaltet ist, und `"bash"` fällt auf PowerShell zurück, wenn Bash nicht installiert ist.

### `dialogExpiry`

Legen Sie die Frist für Dialoge fest, die Claude Code [an einen Remote-Client weiterleitet](https://code.claude.com/docs/de/remote-control.md#limitations), etwa einen Remote-Control- oder SDK-Host, sowie für den Genehmigungsdialog einer [zurückgehaltenen sitzungsübergreifenden Nachricht](https://code.claude.com/docs/de/cross-session-messaging.md#control-inbound-messages). Ab Claude Code v2.1.236 begrenzt dieselbe Frist auch die während der Sitzung erscheinende [Zustimmungsabfrage für Fable-Nutzungsguthaben](https://code.claude.com/docs/de/model-config.md#fable-and-usage-credits) in einer Sitzung, in der möglicherweise niemand am Terminal ist. Wenn vor Ablauf der Frist keine Antwort eingeht, bricht Claude Code den Dialog ab und fährt mit seinem Standard ohne Aktion fort. Erfordert Claude Code v2.1.224 oder höher.

* **Geltungsbereich**: [`User or managed`](#scopes)
* **Typ**: String, einer von `"60s"`, `"5m"`, `"10m"` oder `"never"`, was die Frist deaktiviert
* **Standard**: `"5m"`
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_USER_DIALOG_TIMEOUT_MS`](https://code.claude.com/docs/de/env-vars) hat für eine Sitzung Vorrang vor diesem Schlüssel

```json settings.json theme={null}
{
  "dialogExpiry": "10m"
}
```

Berechtigungsabfragen und [`AskUserQuestion`](https://code.claude.com/docs/de/tools-reference#askuserquestion-tool-behavior)-Fragen verwenden eigene Abläufe und unterliegen dieser Frist nicht. Erscheint in `/config` als **Dialog expiry**, das diesen Schlüssel in die Benutzereinstellungen schreibt; die Zeile erfordert Claude Code v2.1.232 oder höher, und Claude Code blendet sie aus, solange verwaltete Einstellungen oder das Flag `--settings` den Schlüssel setzen.

### `editorMode`

Wählen Sie den Tastenbelegungsmodus für die Eingabeaufforderung.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, einer von:
  * `"normal"`: Standard-Tastenbelegungen in der Prompt-Eingabe
  * `"vim"`: Bearbeitung im vim-Stil mit den Modi NORMAL, INSERT und VISUAL
* **Standard**: `"normal"`

```json settings.json theme={null}
{
  "editorMode": "vim"
}
```

Erscheint in `/config` als **Editor mode**, das diesen Schlüssel in die Benutzereinstellungen schreibt.

### `emojiCompletionEnabled`

Emoji-Vorschläge anzeigen, wenn Sie in der Prompt-Eingabe `:` plus einen Shortcode eingeben, und einen vollständigen Shortcode wie `:heart:` durch sein Emoji ersetzen. Setzen Sie den Schlüssel auf `false`, um beides auszuschalten.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code zeigt nach `:` Emoji-Vorschläge an und ersetzt einen vollständigen Shortcode durch sein Emoji
  * `false`: Claude Code schlägt weder Emojis vor noch ersetzt es Shortcodes
* **Standard**: `true`

```json settings.json theme={null}
{
  "emojiCompletionEnabled": false
}
```

Siehe [Emoji-Shortcodes](https://code.claude.com/docs/de/interactive-mode.md#emoji-shortcodes). Erfordert Claude Code v2.1.217 oder höher.

### `fileSuggestion`

Einen eigenen Befehl ausführen, um die `@`-Autovervollständigung für Dateipfade anstelle der integrierten Dateivorschläge bereitzustellen. Die integrierten Vorschläge verwenden eine schnelle Dateisystemdurchsuchung; bei einem großen Monorepo kann eine projektspezifische Indizierung, etwa ein vorab erstellter Dateiindex, besser geeignet sein.

* **Geltungsbereich**: [`Any file`](#scopes). Unter den [Sperren für Statuszeile und Dateivorschläge](#status-line-and-file-suggestion-gates) schaltet Claude Code den Befehl aus oder führt nur einen verwalteten Wert aus und überspringt Ihren ohne Warnung.
* **Typ**: Objekt mit `type`, immer `"command"`, und `command`, dem auszuführenden Shell-Befehl
* **Standard**: nicht gesetzt, daher verwendet Claude Code die integrierten Dateivorschläge

```json settings.json theme={null}
{
  "fileSuggestion": {
    "type": "command",
    "command": "~/.claude/file-suggestion.sh"
  }
}
```

Nachdem Sie dies gespeichert haben, geben Sie im Prompt `@` gefolgt von einem Teil eines Pfads ein: Die Vorschläge stammen aus der Ausgabe Ihres Befehls.

#### Ein- und Ausgabe des Befehls

Claude Code führt den Befehl mit denselben Umgebungsvariablen wie [Hooks](https://code.claude.com/docs/de/hooks.md) aus, einschließlich `CLAUDE_PROJECT_DIR`, und hört nach fünf Sekunden auf zu warten. Der Befehl erhält auf stdin JSON mit einem Feld `query`, das enthält, was Sie bisher eingegeben haben:

```json theme={null}
{"query": "src/comp"}
```

Geben Sie durch Zeilenumbrüche getrennte Dateipfade auf stdout aus. Claude Code zeigt höchstens 15 an:

```text theme={null}
src/components/Button.tsx
src/components/Modal.tsx
src/components/Form.tsx
```

Das folgende Skript liest die Abfrage und übergibt sie an einen Dateiindex des Repositorys:

```bash theme={null}
#!/bin/bash
query=$(cat | jq -r '.query')
# Replace your-repo-file-index with your own file search command
your-repo-file-index --query "$query" | head -20
```

### `footerLinksRegexes`

Zusätzliche anklickbare Badges in der Fußzeile unterhalb des Eingabefelds rendern, wenn ein regulärer Ausdruck auf die Ausgabe eines Turns passt: Tool-Ergebnisse, einschließlich Dateiinhalten und abgerufener Seiten, sowie Claudes eigene Antworten. Verwenden Sie dies, um IDs, die von Projekt-CLIs wie Review-Tools und Issue-Trackern ausgegeben werden, in Sitzungslinks umzuwandeln.

* **Geltungsbereich**: [`User or managed`](#scopes)
* **Typ**: Array von Objekten, jeweils mit `type` auf `"regex"` gesetzt, einem regulären Ausdruck `pattern`, einer `url`-Vorlage und einem optionalen `label`; `{name}`-Platzhalter in `url` und `label` werden aus benannten Erfassungsgruppen in `pattern` befüllt
* **Standard**: nicht gesetzt, daher werden keine Badges gerendert

Dieses Beispiel erkennt Issue-Schlüssel wie `PROJ-1234` und erstellt jeden Link aus dem erfassten Schlüssel:

```json settings.json theme={null}
{
  "footerLinksRegexes": [
    {
      "type": "regex",
      "pattern": "\\b(?<key>PROJ-\\d+)\\b",
      "url": "https://issues.example.com/browse/{key}",
      "label": "{key}"
    }
  ]
}
```

Wenn dies konfiguriert ist und `PROJ-1234` in einem Tool-Ergebnis oder in Claudes Antwort erscheint, erscheint in der Fußzeile ein Badge `PROJ-1234`, das auf `https://issues.example.com/browse/PROJ-1234` verlinkt.

#### Einschränkungen für Badges

URL, Beschriftung und Badge-Anzahl jedes Eintrags sind wie folgt begrenzt:

| Einschränkung | Verhalten |
| :- | :- |
| URL-Ursprung | Erfasste Werte werden URL-kodiert, und die erstellte URL muss denselben literalen Ursprung wie die Vorlage haben. Eine Erfassung kann ein Pfadsegment oder einen Abfragewert füllen, aber nicht ändern, wohin der Link verweist |
| URL-Länge | Erstellte URLs mit mehr als 2048 Zeichen werden verworfen |
| URL-Schema | Muss `https`, `http` oder ein anerkanntes Deep-Link-Schema für Editoren oder Workspaces sein: `vscode`, `vscode-insiders`, `cursor`, `windsurf`, `zed`, `jetbrains`, `idea`, `slack`, `linear`, `notion`, `figma` |
| Beschriftung | Standardmäßig der übereinstimmende Text, gekürzt auf 28 Anzeigespalten |
| Badge-Anzahl | Höchstens 5 Badges werden gerendert. Das älteste wird durch neuere Treffer verdrängt, und `/clear` entfernt sie |

Wenn ein Turn abgeschlossen ist, gleicht Claude Code den regulären Ausdruck `pattern` jedes Eintrags im Hauptthread mit der Ausgabe des Turns ab, daher blockiert ein langsamer regulärer Ausdruck die Oberfläche, bis er fertig ist. Verschachtelte Quantifizierer wie `(a+)+$` können bei bestimmten Eingaben exponentiell lange dauern und die Sitzung einfrieren, halten Sie daher jedes `pattern` linear und vermeiden Sie verschachtelte `+` oder `*`.

Footer-Badges werden neben einer [benutzerdefinierten Statuszeile](https://code.claude.com/docs/de/statusline.md) gerendert, wenn eine konfiguriert ist; keines ersetzt das andere. Verwenden Sie eine Statuszeile für eine skriptgesteuerte Zeile, die ihren Inhalt selbst aus Sitzungsdaten berechnet, und Footer-Badges, um IDs aus der Konversation ohne Skript in Links umzuwandeln.

### `keybindingFlavor`

> [!WARNING]
>
> Seit v2.1.261 veraltet und ohne Wirkung. Die Tasten zur Wortbearbeitung im Prompt [folgen immer den readline-Konventionen](https://code.claude.com/docs/de/interactive-mode.md#make-ctrl-w-delete-back-to-whitespace), wie in Bash. Claude Code akzeptiert `keybindingFlavor` weiterhin, sodass eine Einstellungsdatei, die den Schlüssel setzt, gültig bleibt.

In v2.1.238 bis v2.1.260 bewirkte der Wert `"readline"`, dass `Ctrl+W` bis zum vorherigen Leerraum löschte statt nur das vorherige Wort.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, `"classic"` oder `"readline"`
* **Standard**: nicht gesetzt

### `maxProseWidth`

Die Breite des Fließtexts in Claudes Antworten begrenzen, damit Zeilen in einem breiten Terminal lesbar bleiben. Absätze, Überschriften, Listen und Blockzitate werden innerhalb dieser Anzahl von Spalten umbrochen, während Tabellen und Codeblöcke die volle Terminalbreite behalten. Erfordert Claude Code v2.1.282 oder höher.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Anzahl der Terminalspalten, eine ganze Zahl, mindestens `40`. Claude Code ignoriert jeden anderen Wert
* **Standard**: nicht gesetzt, daher wird Fließtext am Rand des Terminals umbrochen

```json settings.json theme={null}
{
  "maxProseWidth": 80
}
```

### `prefersReducedMotion`

Animationen der Oberfläche wie den Spinner sowie Schimmer- und Blitzeffekte reduzieren oder ausschalten. Erscheint in `/config` als **Reduce motion**.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code reduziert Animationen der Oberfläche wie den Spinner sowie Schimmer- und Blitzeffekte oder schaltet sie aus
  * `false`: wie nicht gesetzt; Claude Code zeigt seine Animationen
* **Standard**: `false`

```json settings.json theme={null}
{
  "prefersReducedMotion": true
}
```

### `promptSuggestionEnabled`

[Prompt-Vorschläge](https://code.claude.com/docs/de/interactive-mode.md#prompt-suggestions) anzeigen oder ausblenden, also die ausgegrauten Vorhersagen, die in Ihrer Prompt-Eingabe erscheinen. Setzen Sie den Schlüssel auf `false` oder schalten Sie **Prompt suggestions** in `/config` aus, um sie auszublenden.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Sie sehen Prompt-Vorschläge in Ihrer Prompt-Eingabe
  * `false`: Claude Code blendet Prompt-Vorschläge aus
* **Standard**: `true`
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION`](https://code.claude.com/docs/de/env-vars) hat für eine Sitzung Vorrang vor diesem Schlüssel

```json settings.json theme={null}
{
  "promptSuggestionEnabled": false
}
```

Prompt-Vorschläge erfordern ein claude.ai- oder Console-Konto mit eingeschalteter Telemetrie. Bei Amazon Bedrock, Google Clouds Agent Platform und Microsoft Foundry oder bei ausgeschalteter Telemetrie, etwa durch [`DISABLE_TELEMETRY`](https://code.claude.com/docs/de/env-vars), hat dieser Schlüssel keine Wirkung, und nur `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION=1` schaltet sie ein.

### `respectGitignore`

Steuern, ob die `@`-Dateiauswahl Dateien auslässt, die auf `.gitignore`-Muster passen. Erscheint in `/config` als **Respect .gitignore in file picker**.

* **Geltungsbereich**: [`Any file`](#scopes). Wenn keine Einstellungsdatei den Schlüssel setzt, greift Claude Code auf `respectGitignore` in `~/.claude.json` zurück, das vom Schalter in `/config` geschrieben wird.
* **Typ**: Boolean
  * `true`: Die `@`-Dateiauswahl lässt Dateien aus, die auf `.gitignore`-Muster passen
  * `false`: Die `@`-Dateiauswahl schließt Dateien ein, die auf `.gitignore`-Muster passen
* **Standard**: `true`

```json settings.json theme={null}
{
  "respectGitignore": false
}
```

### `respondToBashCommands`

Legen Sie fest, ob Claude antwortet, nachdem Sie einen Shell-Befehl mit dem [`!`-Präfix](https://code.claude.com/docs/de/interactive-mode#shell-mode-with-prefix) im Eingabefeld ausgeführt haben. Standardmäßig fügt Claude Code die Ausgabe des Befehls der Konversation hinzu, und Claude antwortet darauf. Setzen Sie diesen Schlüssel auf `false`, um die Ausgabe ohne Antwort dem Kontext hinzuzufügen, sodass Sie mehrere Befehle ausführen und gemeinsam danach fragen können.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code fügt die Ausgabe des Befehls der Konversation hinzu, und Claude antwortet darauf
  * `false`: Claude Code fügt die Ausgabe ohne Antwort dem Kontext hinzu
* **Standard**: `true`

```json settings.json theme={null}
{
  "respondToBashCommands": false
}
```

Siehe [Shell-Modus mit `!`-Präfix](https://code.claude.com/docs/de/interactive-mode#shell-mode-with-prefix).

### `showClearContextOnPlanAccept`

Wenn Claude im [Plan-Modus](https://code.claude.com/docs/de/permission-modes.md#review-and-approve-a-plan) einen Plan fertigstellt, zeigt es ein Genehmigungsmenü an. Das Planen kann viel Kontext verbrauchen, daher fügt dieser Schlüssel dem Menü eine erste Option hinzu, **Yes, clear context and …**, die den Plan genehmigt, den Konversationskontext leert und die Implementierung allein auf Grundlage des Plans beginnt. Der Rest der Beschriftung nennt den Berechtigungsmodus, in dem die Sitzung fortgesetzt wird, und zeigt, wie viel Ihres Kontexts das Planen verbraucht hat.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Das Menü zur Plan-Genehmigung erhält eine erste Option, **Yes, clear context and …**, die den Plan genehmigt und den Konversationskontext leert
  * `false`: Das Menü zur Plan-Genehmigung zeigt keine Option zum Leeren des Kontexts
* **Standard**: `false`

```json settings.json theme={null}
{
  "showClearContextOnPlanAccept": true
}
```

### `showTurnDuration`

Die Meldung zur Turn-Dauer nach jeder Antwort anzeigen oder ausblenden, etwa „Cooked for 1m 6s · done 6:05 PM“. Die Uhrzeit nach „done“ zeigt, wann der Turn beendet wurde; [`timeFormat`](#timeformat) und [`timeZone`](#timezone) steuern ihr Format und ihre Zeitzone. Erscheint in `/config` als **Show turn duration**.

* **Geltungsbereich**: [`Any file`](#scopes). Ein Wert in `~/.claude.json` aus einer älteren Version gilt, wenn keine Einstellungsdatei den Schlüssel setzt.
* **Typ**: Boolean
  * `true`: Sie sehen nach jeder Antwort die Meldung zur Turn-Dauer
  * `false`: Claude Code blendet die Meldung zur Turn-Dauer aus
* **Standard**: `true`

```json settings.json theme={null}
{
  "showTurnDuration": false
}
```

### `spellcheck`

Falsch geschriebene Wörter in der Prompt-Eingabe während der Eingabe unterstreichen, mithilfe einer von Ihnen installierten Rechtschreibprüfung. Claude Code prüft nur den Text im Eingabefeld. [Rechtschreibung während der Eingabe prüfen](https://code.claude.com/docs/de/interactive-mode.md#check-spelling-as-you-type) behandelt die Installation von aspell, hunspell oder ispell und was die Prüfung abdeckt. Erfordert Claude Code v2.1.235 oder höher.

* **Geltungsbereich**: [`User or managed`](#scopes). Der Block aus der höchsten Ebene, die den Schlüssel setzt, gilt als Ganzes.
* **Typ**: Objekt mit `enabled` (Boolean), `checker` (`"aspell"`, `"hunspell"`, `"ispell"` oder `"auto"`), `language` (String, wird an die Prüfung als Name ihres Wörterbuchs übergeben) und `color` (String, ein Terminal-Farbname, `#rrggbb`, `rgb(r,g,b)`, `ansi256(n)` oder `ansi:<name>`)
* **Standard**: nicht gesetzt, daher ist die Rechtschreibprüfung aus; `checker` ist standardmäßig `"auto"`, also die erste der drei Prüfungen, die auf dem `PATH` gefunden wird; `language` ist standardmäßig das eigene Wörterbuch der Prüfung; `color` ist standardmäßig die Fehlerfarbe des Themes

```json settings.json theme={null}
{
  "spellcheck": { "enabled": true, "language": "en_GB" }
}
```

### `spinnerTipsEnabled`

Während Claude arbeitet, zeigt die Spinner-Zeile abwechselnd kurze Tipps zu Funktionen von Claude Code an, etwa „Use Plan Mode to prepare for a complex request before making changes. Press Shift+Tab twice to enable.“ Setzen Sie diesen Schlüssel auf `false`, um sie auszublenden. Erscheint in `/config` als **Show tips**.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Sie sehen Tipps im Spinner, während Claude arbeitet
  * `false`: Claude Code blendet Spinner-Tipps aus
* **Standard**: `true`

```json settings.json theme={null}
{
  "spinnerTipsEnabled": false
}
```

### `spinnerTipsOverride`

Eigene Tipps zu den [Spinner-Tipps](#spinnertipsenabled) hinzufügen, die Claude Code anzeigt, während Claude arbeitet, oder die integrierten Tipps durch Ihre ersetzen. Claude Code nimmt Ihre Tipps in dieselbe Rotation auf wie die integrierten.

Wenn Sie [`spinnerTipsEnabled`](#spinnertipsenabled) auf `false` setzen, blendet Claude Code alle Tipps aus, auch Ihre.

* **Geltungsbereich**: [`Any file`](#scopes). Claude Code berücksichtigt Tipp-Objekte, `tipsFile`, `label` und `excludeDefault` aus den Benutzereinstellungen, dem Flag `--settings` und verwalteten Einstellungen; aus Projekt- und lokalen Einstellungen liest es nur einfache String-Tipps.
* **Typ**: Objekt mit den Feldern `tips`, `tipsFile`, `label` und `excludeDefault`, jeweils optional
* **Standard**: nicht gesetzt, daher zeigt Claude Code nur die integrierten Tipps

Tipp-Objekte, `tipsFile`, `label` und die Regel aus der Zeile zum Geltungsbereich, dass Projekt- und lokale Einstellungen nur einfache Strings beitragen, erfordern Claude Code v2.1.247 oder höher.

Jeder `tips`-Eintrag ist ein einfacher String oder ein Objekt mit diesen Feldern:

| Feld | Erforderlich | Beschreibung |
| :- | :- | :- |
| `id` | Ja | Bis zu 64 Buchstaben, Ziffern, `.`, `_` oder `-`. Claude Code verknüpft den Anzeigeverlauf des Tipps mit diesem Wert, sodass die Wartezeit des Tipps ein Umsortieren der Liste übersteht. Von zwei Einträgen mit derselben ID verwendet Claude Code den ersten |
| `text` | Ja | Der Tipp, eine Zeile mit bis zu 500 Zeichen. Claude Code entfernt ANSI-Escape-Sequenzen und Steuerzeichen und fasst Leerraum zusammen |
| `cooldownSessions` | Nein | Anzahl der Sitzungen, die Claude Code wartet, bevor es den Tipp erneut anzeigt, `0` bis `1000`, Standard `0` |
| `priority` | Nein | Reihenfolge unter Tipps, die gleich lange nicht angezeigt wurden, höhere zuerst, `-10` bis `10`, Standard `0` |

Claude Code liest einen einfachen String als Tipp mit diesen Standardwerten und einer positionsbasierten ID, sodass sein Anzeigeverlauf zurückgesetzt wird, wenn Sie die Liste umsortieren. Geben Sie einem Tipp eine `id`, um seinen Verlauf über Bearbeitungen hinweg zu behalten.

Claude Code liest höchstens 200 Tipps aus `tips` und `tipsFile` zusammen und verwirft einen ungültigen Eintrag mit einer Debug-Warnung, statt die Einstellungsdatei abzulehnen.

Verwenden Sie die übrigen Felder, um eine Tipp-Datei anzugeben, das Präfix festzulegen und die integrierten Tipps auszublenden:

* `tipsFile`: ein absoluter oder mit `~/` beginnender Pfad zu einer lokalen JSON-Datei, die ein Array derselben Einträge oder ein Objekt mit einem `tips`-Array enthält, bis zu 256 KB. Claude Code liest die Datei einmal pro Prozess, daher lädt es Ihre Änderungen beim nächsten Start. Sie können sie nicht über [serververwaltete Einstellungen](https://code.claude.com/docs/de/server-managed-settings.md) festlegen; stellen Sie dort Inline-`tips` bereit, oder stellen Sie den Pfad in einer `managed-settings.json` auf dem Datenträger bereit.
* `label`: das Präfix, das Claude Code vor Tipps aus Benutzereinstellungen, `--settings` und verwalteten Einstellungen anzeigt, bis zu 40 Zeichen. Der Standard ist `Tip`, dasselbe Präfix wie bei den integrierten Tipps, und Tipps aus Projekt- und lokalen Einstellungen verwenden es immer.
* `excludeDefault`: Setzen Sie es auf `true`, um die integrierten Tipps auszublenden und nur Ihre anzuzeigen. Wenn Claude Code keinen Ihrer Tipps laden kann, zum Beispiel weil `tipsFile` nicht existiert oder jeder Eintrag ungültig ist, behält es die integrierte Rotation bei, statt einen leeren Spinner anzuzeigen.

Wenn mehr als eine Einstellungsdatei den Schlüssel setzt, zeigt Claude Code Tipps aus allen an und übernimmt `tipsFile`, `label` und `excludeDefault` jeweils aus derjenigen der verwalteten Einstellungen, des Flags `--settings` und der Benutzereinstellungen, die den höchsten Vorrang hat und das jeweilige Feld setzt.

Dieses Beispiel in Ihren Benutzereinstellungen fügt der Rotation einen einfachen String-Tipp und einen Objekt-Tipp unter dem Präfix `Acme tip` hinzu:

```json settings.json theme={null}
{
  "spinnerTipsOverride": {
    "label": "Acme tip",
    "tips": [
      "Run /review before opening a PR",
      {
        "id": "gateway-errors",
        "text": "Seeing 5xx errors? Check the gateway status page first",
        "cooldownSessions": 5,
        "priority": 2
      }
    ]
  }
}
```

Jedes Feld im Beispiel ändert einen Aspekt daran, wie Claude Code die Tipps anzeigt:

* `label`: Claude Code zeigt beide Tipps als `Acme tip: ...` statt `Tip: ...` an.
* Der einfache String: Claude Code gibt ihm die Standardwerte, daher kann er gleich in der nächsten Sitzung wieder erscheinen.
* `id`: Claude Code verknüpft den Anzeigeverlauf des zweiten Tipps mit `gateway-errors`, sodass seine Wartezeit weiterhin gilt, nachdem Sie Tipps hinzufügen oder umsortieren.
* `cooldownSessions`: Nachdem Claude Code den Tipp `gateway-errors` angezeigt hat, zeigt es ihn erst fünf Sitzungen später wieder an.
* `priority`: Wenn der Tipp `gateway-errors` und ein anderer Tipp gleich viele Sitzungen lang nicht angezeigt wurden, zum Beispiel wenn noch keiner von beiden angezeigt wurde, zeigt Claude Code `gateway-errors` zuerst an. Der einfache String hat die Standardpriorität `0`.

Während Claude arbeitet, zeigt Claude Code Ihre Tipps im Spinner mit Ihrem Präfix an, etwa `Acme tip: Run /review before opening a PR`.

### `spinnerVerbs`

Während ein Turn läuft, zeigt der Spinner ein wechselndes Verb wie „Accomplishing“, „Architecting“ oder „Baking“. Verwenden Sie diesen Schlüssel, um dieser Rotation eigene Verben hinzuzufügen oder die integrierte Liste durch Ihre zu ersetzen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Objekt mit einem Array `verbs` aus Strings und `mode`, einer von:
  * `"append"`: Claude Code fügt Ihre Verben zum integrierten Satz hinzu
  * `"replace"`: Claude Code zeigt nur Ihre Verben
* **Standard**: nicht gesetzt, daher verwendet Claude Code die integrierten Verben

Dieses Beispiel fügt dem integrierten Satz zwei Verben hinzu:

```json settings.json theme={null}
{
  "spinnerVerbs": {
    "mode": "append",
    "verbs": ["Pondering", "Crafting"]
  }
}
```

Im Modus `"replace"` mit einem leeren Array `verbs` behält Claude Code die integrierten Verben bei.

### `statusLine`

Einen eigenen Befehl ausführen, um unterhalb des Prompts eine [Statuszeile](https://code.claude.com/docs/de/statusline.md) mit Kontext wie dem Modell, den Kosten oder dem Git-Branch zu rendern. Optionale Felder passen den Abstand an, fügen periodische erneute Ausführungen hinzu und blenden die integrierte vim-Modusanzeige aus, wenn Ihr Skript `vim.mode` selbst rendert.

* **Geltungsbereich**: [`Any file`](#scopes). Wenn [`allowManagedHooksOnly`](#allowmanagedhooksonly) eingeschaltet ist oder [`disableAllHooks`](#disableallhooks) außerhalb verwalteter Einstellungen gesetzt ist, wird nur der Wert aus den verwalteten Einstellungen ausgeführt.
* **Typ**: Objekt mit `type` auf `"command"` gesetzt und einem String `command`, dazu optional `padding` als Anzahl von Zeichen, `refreshInterval` als Anzahl von Sekunden, mindestens `1`, und `hideVimModeIndicator` als Boolean
* **Standard**: nicht gesetzt, daher keine Statuszeile

Dieses Beispiel gibt den Modellnamen und die Kontextnutzung aus und fügt zwei Zeichen horizontalen Abstand hinzu:

```json settings.json theme={null}
{
  "statusLine": {
    "type": "command",
    "command": "jq -r '\"[\\(.model.display_name)] \\(.context_window.used_percentage // 0)% context\"'",
    "padding": 2
  }
}
```

Das Beispiel erfordert ein installiertes [`jq`](https://jqlang.org/) und läuft in einer Shell. Entsprechungen für PowerShell und Git Bash finden Sie unter [Windows-Konfiguration](https://code.claude.com/docs/de/statusline.md#windows-configuration); die vollständige Einrichtung finden Sie unter [Eine Statuszeile manuell konfigurieren](https://code.claude.com/docs/de/statusline.md#manually-configure-a-status-line).

### `subagentStatusLine`

Wenn Claude [Subagenten](https://code.claude.com/docs/de/sub-agents.md) ausführt, listet Claude Code sie in einer Aufgabenanzeige unterhalb des Prompts auf, eine Zeile pro Subagent mit `name · description · token count`. Mit diesem Schlüssel können Sie einen eigenen Befehl ausführen, um diese Zeilen umzuschreiben, zum Beispiel um die Kontextnutzung jedes Subagenten als Prozentsatz anzuzeigen. Bei jeder Aktualisierung sendet Claude Code die sichtbaren Zeilen als ein JSON-Objekt auf stdin, mit einem Array `tasks`, das für jeden Subagenten `id`, `name`, `status`, `model`, `tokenCount` und mehr enthält, und ersetzt die Zeile für jede `id`, die Sie als `{"id", "content"}`-Zeile zurückschreiben. Zeilen, die Sie nicht zurückschreiben, behalten die Standarddarstellung.

* **Geltungsbereich**: [`Any file`](#scopes). Wenn [`allowManagedHooksOnly`](#allowmanagedhooksonly) eingeschaltet ist oder [`disableAllHooks`](#disableallhooks) außerhalb verwalteter Einstellungen gesetzt ist, wird nur der Wert aus den verwalteten Einstellungen ausgeführt.
* **Typ**: Objekt mit `type` auf `"command"` gesetzt und einem String `command`
* **Standard**: nicht gesetzt, daher rendert Claude Code die Standardzeilen

```json settings.json theme={null}
{
  "subagentStatusLine": {
    "type": "command",
    "command": "jq -c '.tasks[] | {id, content: \"\\(.name): \\(.tokenCount) tokens\"}'"
  }
}
```

Siehe [Statuszeilen für Subagenten](https://code.claude.com/docs/de/statusline.md#subagent-status-lines).

### `syntaxHighlightingDisabled`

Claude Code färbt Code in den Diffs, Codeblöcken und Dateivorschauen, die es im Terminal anzeigt, mit seinem integrierten Highlighter sprachabhängig ein; dabei ist weder ein Plugin noch ein Language Server beteiligt. Setzen Sie diesen Schlüssel auf `true`, um sie stattdessen als einfachen Text anzuzeigen, zum Beispiel wenn die Farben nicht zu Ihrem Terminal-Theme passen oder einen Screenreader verlangsamen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code schaltet die Syntaxhervorhebung in Diffs, Codeblöcken und Dateivorschauen aus
  * `false`: Claude Code hebt die Syntax hervor
* **Standard**: `false`

```json settings.json theme={null}
{
  "syntaxHighlightingDisabled": true
}
```

### `terminalProgressBarEnabled`

Manche Terminals können für das darin laufende Programm eine Fortschrittsanzeige auf dem Tab oder in der Taskleiste anzeigen. Während Claude arbeitet, meldet Claude Code dem Terminal einen laufenden Zustand, sodass Sie von einem anderen Tab oder Fenster aus sehen können, ob die Sitzung noch beschäftigt ist. Die Anzeige bleibt nach dem Ende des Turns sichtbar, solange [Hintergrund-Subagenten](https://code.claude.com/docs/de/sub-agents.md#run-subagents-in-foreground-or-background) oder [dynamische Workflows](https://code.claude.com/docs/de/workflows.md) noch laufen, und verschwindet, sobald die Sitzung im Leerlauf ist.

Claude Code meldet sie nur in Terminals, die die Anzeige unterstützen: ConEmu, Ghostty 1.2.0 oder höher und iTerm2 3.6.6 oder höher. Setzen Sie diesen Schlüssel auf `false`, damit Claude Code sie nicht mehr meldet. Erscheint in `/config` als **Terminal progress bar**.

* **Geltungsbereich**: [`Any file`](#scopes). Ein Wert in `~/.claude.json` aus einer älteren Version gilt, wenn keine Einstellungsdatei den Schlüssel setzt.
* **Typ**: Boolean
  * `true`: Sie sehen die Terminal-Fortschrittsanzeige in Terminals, die sie unterstützen
  * `false`: Claude Code blendet die Terminal-Fortschrittsanzeige aus
* **Standard**: `true`

```json settings.json theme={null}
{
  "terminalProgressBarEnabled": false
}
```

### `terminalTitleFromRename`

Claude Code setzt den Titel Ihres Terminal-Tabs. Standardmäßig verwendet es einen Titel, den es aus der Konversation generiert, und sobald Sie der Sitzung mit `/rename` oder `--name` einen [Namen](https://code.claude.com/docs/de/sessions.md#name-your-sessions) geben, zeigt der Tab stattdessen diesen Namen. Setzen Sie diesen Schlüssel auf `false`, um den generierten Titel auf dem Tab zu behalten, auch nachdem Sie die Sitzung benannt haben. Der Name selbst gilt weiterhin, sodass `/resume <name>` und die Sitzungsauswahl ihn finden.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Der Titel des Terminal-Tabs zeigt den von Ihnen festgelegten Sitzungsnamen
  * `false`: Der Tab behält den Titel, den Claude Code aus Ihrer Konversation generiert
* **Standard**: `true`

```json settings.json theme={null}
{
  "terminalTitleFromRename": false
}
```

Damit Claude Code den Terminaltitel überhaupt nicht mehr aktualisiert, setzen Sie stattdessen [`CLAUDE_CODE_DISABLE_TERMINAL_TITLE`](https://code.claude.com/docs/de/env-vars) auf `1`.

### `theme`

Das Farbschema für die Oberfläche wählen. Erscheint in `/config` als **Theme**.

* **Geltungsbereich**: [`Any file`](#scopes). Ein Wert in `~/.claude.json` aus einer älteren Version gilt, wenn keine Einstellungsdatei den Schlüssel setzt.
* **Typ**: String, einer von:
  * `"auto"`: passt sich dem hellen oder dunklen Hintergrund Ihres Terminals an
  * `"dark"`: das dunkle Theme
  * `"light"`: das helle Theme
  * `"dark-daltonized"`: das dunkle Theme mit farbenblindfreundlichen Farben
  * `"light-daltonized"`: das helle Theme mit farbenblindfreundlichen Farben
  * `"dark-ansi"`: das dunkle Theme, das nur die ANSI-Farbpalette Ihres Terminals verwendet
  * `"light-ansi"`: das helle Theme, das nur die ANSI-Farbpalette Ihres Terminals verwendet
  * `"custom:<slug>"` oder `"custom:<plugin-name>:<slug>"`: ein benutzerdefiniertes Theme aus `~/.claude/themes/` oder aus einem Plugin
* **Standard**: `"dark"`

```json settings.json theme={null}
{
  "theme": "light-daltonized"
}
```

Siehe [Ein benutzerdefiniertes Theme erstellen](https://code.claude.com/docs/de/terminal-config.md#create-a-custom-theme).

### `timeFormat`

Legen Sie fest, wie Claude Code die Uhrzeiten schreibt, die es in der Oberfläche anzeigt, etwa `done 6:05 PM` am Ende jeder Meldung zur Turn-Dauer und die Zeitstempel im [Transkript-Viewer](https://code.claude.com/docs/de/interactive-mode.md#transcript-viewer). Um eine Vorgabe auszuwählen, führen Sie `/config` aus und setzen **Time format**. Erfordert Claude Code v2.1.257 oder höher.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, einer von:
  * `"auto"`: wie nicht gesetzt; jede Uhrzeit behält ihr integriertes Format, das bei der Meldung zur Turn-Dauer Ihrem Gebietsschema folgt
  * `"12-hour"`: eine 12-Stunden-Uhr
  * `"24-hour"`: eine 24-Stunden-Uhr
  * `"24-hour-utc"`: eine 24-Stunden-Uhr in UTC mit `Z` nach den Minuten, etwa `18:05Z`; Claude Code ignoriert [`timeZone`](#timezone) für diese Vorgabe
  * Ein strftime-Muster wie `"%H:%M"`: Claude Code schreibt jede Uhrzeit mit dem Muster. Jeder Wert, der ein `%` enthält, ist ein Muster, und jeder andere Wert außerhalb der Vorgaben zählt als `"auto"`
* **Standard**: `"auto"`

```json settings.json theme={null}
{
  "timeFormat": "24-hour"
}
```

`/config` bietet nur die Vorgaben an; um ein strftime-Muster zu verwenden, fügen Sie den Schlüssel daher einer Einstellungsdatei hinzu. Dieses Beispiel zeigt jede Uhrzeit als zweistellige 24-Stunden-Uhr:

```json settings.json theme={null}
{
  "timeFormat": "%H:%M"
}
```

Die Meldung zur Turn-Dauer und der Transkript-Viewer zeigen dann Uhrzeiten wie `18:05`. Im Transkript-Viewer bildet das Muster den gesamten Zeitstempel, fügen Sie daher Datumsdirektiven hinzu, wenn Sie dort das Datum sehen möchten. Dieses Beispiel stellt das Datum vor die Uhrzeit:

```json settings.json theme={null}
{
  "timeFormat": "%Y-%m-%d %H:%M"
}
```

Dieselben Oberflächen zeigen dann Uhrzeiten wie `2026-09-01 18:05`.

### `timeZone`

Die Uhrzeiten in der Oberfläche in einer anderen Zeitzone als der Ihres Systems anzeigen. Setzen Sie den Schlüssel auf einen [IANA-Zeitzonennamen](https://www.iana.org/time-zones), etwa `"UTC"` oder `"Europe/Dublin"`. Die Uhrzeiten, die [`timeFormat`](#timeformat) steuert, werden dann in dieser Zone angezeigt. Wenn `timeFormat` auf `"24-hour-utc"` steht, bleiben die Uhrzeiten in UTC, und Claude Code ignoriert diesen Schlüssel. `/config` hat keine Zeile für diesen Schlüssel, setzen Sie ihn daher in einer Einstellungsdatei. Erfordert Claude Code v2.1.257 oder höher.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, ein IANA-Zeitzonenname. Wenn Claude Code den Namen nicht erkennt, verwendet es Ihre Systemzeitzone
* **Standard**: nicht gesetzt, daher werden Uhrzeiten in Ihrer Systemzeitzone angezeigt

```json settings.json theme={null}
{
  "timeZone": "Europe/Dublin"
}
```

### `tui`

Den Renderer der Terminal-Oberfläche wählen. Verwenden Sie `"fullscreen"` für den flackerfreien [Alt-Screen-Renderer](https://code.claude.com/docs/de/fullscreen.md) mit virtualisiertem Scrollback oder `"default"` für den klassischen Main-Screen-Renderer. Wenn Sie `/tui fullscreen` oder `/tui default` ausführen, wird dieser Schlüssel für Sie geschrieben.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, einer von:
  * `"default"`: der klassische Main-Screen-Renderer
  * `"fullscreen"`: der flackerfreie Alt-Screen-Renderer mit virtualisiertem Scrollback
* **Standard**: nicht gesetzt, daher [wählt Claude Code den Renderer für Sie](https://code.claude.com/docs/de/fullscreen.md#fullscreen-by-default)
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_NO_FLICKER`](https://code.claude.com/docs/de/env-vars) und [`CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN`](https://code.claude.com/docs/de/env-vars) haben für eine Sitzung Vorrang vor diesem Schlüssel: `CLAUDE_CODE_NO_FLICKER=1` schaltet den Vollbildmodus ein, und `CLAUDE_CODE_NO_FLICKER=0` oder `CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN=1` schaltet ihn aus; wenn beide gesetzt sind, schaltet Claude Code ihn aus

```json settings.json theme={null}
{
  "tui": "fullscreen"
}
```

Unter tmux `-CC` oder über SSH zu Windows behält Claude Code den klassischen Renderer bei, sofern Sie nicht `CLAUDE_CODE_NO_FLICKER=1` setzen. Hintergrundsitzungen, die aus der [Agentenansicht](https://code.claude.com/docs/de/agent-view.md) geöffnet werden, verwenden unabhängig von dieser Einstellung immer den Vollbild-Renderer.

### `verbose`

Standardmäßig fasst das Transkript jeden Tool-Aufruf zu einer kurzen Zusammenfassung zusammen, etwa dem Befehl, den Claude ausgeführt hat, und der Zeilenanzahl seiner Ausgabe, und Sie drücken `Ctrl+O`, um das gesamte Transkript in die erweiterte Ansicht umzuschalten, wenn Sie die Details sehen möchten. Setzen Sie diesen Schlüssel auf `true`, um die vollständige Ein- und Ausgabe jedes Tool-Aufrufs direkt beim Auftreten inline anzuzeigen, was beim Debugging eines Hooks, eines MCP-Servers oder eines langen Shell-Befehls nützlich ist. Erscheint in `/config` als **Verbose output**.

* **Geltungsbereich**: [`Any file`](#scopes). Ein Wert in `~/.claude.json` aus einer älteren Version gilt, wenn keine Einstellungsdatei den Schlüssel setzt.
* **Typ**: Boolean
  * `true`: Sie sehen die vollständige Tool-Ausgabe
  * `false`: Sie sehen gekürzte Zusammenfassungen der Tool-Ausgabe
* **Standard**: `false`
* **Überschreibungen pro Sitzung**: [`--verbose`](https://code.claude.com/docs/de/cli-reference#cli-flags) hat für eine Sitzung Vorrang vor diesem Schlüssel

```json settings.json theme={null}
{
  "verbose": true
}
```

Ein [`viewMode`](#viewmode)-Wert oder eine dauerhafte `/focus`-Auswahl überschreibt diesen Schlüssel in jeder Sitzung.

### `viewMode`

Die Transkriptansicht festlegen, mit der Claude Code startet: `"default"`, `"verbose"` oder `"focus"`. Wenn gesetzt, überschreibt der Schlüssel sowohl die dauerhafte `/focus`-Auswahl als auch die Einstellung [`verbose`](#verbose).

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, einer von:
  * `"default"`: das normale Transkript mit gekürzter Tool-Ausgabe
  * `"verbose"`: das Transkript mit vollständiger Tool-Ausgabe
  * `"focus"`: nur Ihr letzter Prompt, eine einzeilige Zusammenfassung der Tool-Aufrufe mit Diffstats der Bearbeitungen und die abschließende Antwort. Die Fokusansicht erfordert den [Vollbild-Renderer](#tui)
* **Standard**: nicht gesetzt, daher gelten die Einstellung `verbose` und Ihre letzte `/focus`-Auswahl
* **Überschreibungen pro Sitzung**: [`--verbose`](https://code.claude.com/docs/de/cli-reference#cli-flags) hat für eine Sitzung Vorrang vor diesem Schlüssel

```json settings.json theme={null}
{
  "viewMode": "focus"
}
```

### `vimInsertModeRemaps`

Zwei-Tasten-Sequenzen im INSERT-Modus im [vim-Editor-Modus](https://code.claude.com/docs/de/interactive-mode.md#vim-editor-mode) auf Escape abbilden. Jeder Schlüssel besteht aus genau zwei druckbaren Zeichen, die nacheinander eingegeben werden, und `"<Esc>"` ist das einzige unterstützte Ziel; Claude Code ignoriert andere Einträge.

* **Geltungsbereich**: [`User or managed`](#scopes). Ein Repository kann Ihre Tastenanschläge nicht umbelegen.
* **Typ**: Objekt, das eine Sequenz aus zwei Zeichen auf `"<Esc>"` abbildet
* **Standard**: nicht gesetzt

```json settings.json theme={null}
{
  "vimInsertModeRemaps": {
    "jj": "<Esc>"
  }
}
```

Hat keine Wirkung, sofern `editorMode` nicht `"vim"` ist. Siehe [Tastensequenzen im INSERT-Modus umbelegen](https://code.claude.com/docs/de/interactive-mode.md#remap-insert-mode-key-sequences).

### `voice`

[Sprachdiktat](https://code.claude.com/docs/de/voice-dictation.md) einschalten und festlegen, wie sich die Diktiertaste verhält. Claude Code schreibt dieses Objekt für Sie, wenn Sie `/voice` ausführen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Objekt mit `enabled` als Boolean, `autoSubmit` als Boolean, das nur im Haltemodus gilt, und `mode`, einer von:
  * `"hold"`: Sie halten die Diktiertaste beim Sprechen gedrückt und lassen sie los, um zu stoppen
  * `"tap"`: Sie tippen die Taste einmal an, um die Aufnahme zu starten, und erneut, um zu senden
* **Standard**: nicht gesetzt, daher ist das Diktat aus; wenn `enabled` auf `true` steht und `mode` nicht gesetzt ist, verwendet Claude Code `"hold"`

Dieses Beispiel schaltet das Diktat ein und legt fest, dass die Taste einmal angetippt wird, um die Aufnahme zu starten, und erneut, um zu senden:

```json settings.json theme={null}
{
  "voice": {
    "enabled": true,
    "mode": "tap"
  }
}
```

`autoSubmit` sendet den Prompt, wenn Sie die Taste im Haltemodus loslassen. Sprachdiktat erfordert ein claude.ai-Konto.

### `voiceEnabled`

> [!WARNING]
>
> Seit v2.1.92 veraltet, als das Objekt [`voice`](#voice) diesen Schlüssel ersetzt hat. Claude Code liest ihn weiterhin, damit ältere Einstellungsdateien funktionieren, neue Konfigurationen sollten jedoch `voice.enabled` setzen.

Sprachdiktat mit der einfachen Boolean-Form einschalten, die älter ist als das Objekt `voice`. Wenn beide gesetzt sind, gilt `voice.enabled`.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Sprachdiktat ist eingeschaltet, wenn Sie mit einem claude.ai-Konto angemeldet sind und die Richtlinie Ihrer Organisation Sprache zulässt, sofern `voice.enabled` nicht gesetzt ist
  * `false`: Sprachdiktat ist ausgeschaltet, sofern `voice.enabled` nicht gesetzt ist
* **Standard**: nicht gesetzt

```json settings.json theme={null}
{
  "voiceEnabled": true
}
```

### `wheelScrollAccelerationEnabled`

Die Scrollgeschwindigkeit des Mausrads bei schnellem Scrollen im [Vollbild-Rendering](https://code.claude.com/docs/de/fullscreen.md#mouse-wheel-scrolling) beschleunigen. Setzen Sie den Schlüssel auf `false` für eine konstante Scrollrate pro Mausradraste.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code beschleunigt die Scrollgeschwindigkeit des Mausrads bei schnellem Scrollen
  * `false`: Claude Code scrollt mit einer konstanten Rate pro Mausradraste
* **Standard**: `true`

```json settings.json theme={null}
{
  "wheelScrollAccelerationEnabled": false
}
```

## Git und Zuordnung

Steuern Sie die Zuordnung, die Claude Code zu Commits und Pull Requests hinzufügt, und wie sie mit Git funktioniert.

### `attribution`

Passen Sie die Zuordnung an, die Claude Code zu Git-Commits und Pull Requests hinzufügt. Commits erhalten standardmäßig einen [Git-Trailer](https://git-scm.com/docs/git-interpret-trailers) wie `Co-Authored-By`; Pull-Request-Beschreibungen erhalten Klartext. Legen Sie jeden Teil separat mit den folgenden Unterschlüsseln fest.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Objekt mit `commit`- und `pr`-Zeichenketten und einem `sessionUrl`-Boolean, oder `false`, um alle Zuordnungen auszublenden. Der Wert `false` erfordert Claude Code v2.1.281 oder später; frühere Versionen lehnen ihn ab und [überspringen die gesamte Benutzer-, Projekt- oder lokale Einstellungsdatei](https://code.claude.com/docs/de/settings.md#fix-a-broken-settings-file), die ihn enthält
* **Standard**: nicht gesetzt, daher verwendet Claude Code die unter jedem Unterschlüssel angezeigte Standard-Zuordnung

Um alle Zuordnungen auszublenden, setzen Sie `attribution` auf `false`. In einer Einstellungsdatei, die auch frühere Versionen lesen, setzen Sie stattdessen [`commit`](#attribution-commit) und [`pr`](#attribution-pr) auf leere Zeichenketten und [`sessionUrl`](#attribution-sessionurl) auf `false`.

Dieses Beispiel ersetzt die Commit-Zuordnung, entfernt die Pull-Request-Zuordnung und löscht den Sitzungslink:

```json settings.json theme={null}
{
  "attribution": {
    "commit": "Generated with AI\n\nCo-Authored-By: AI <ai@example.com>",
    "pr": "",
    "sessionUrl": false
  }
}
```

Sobald Sie `commit` oder `pr` setzen, ignoriert Claude Code die veraltete Einstellung `includeCoAuthoredBy` und verwendet seinen Standard-Text für denjenigen der beiden, den Sie nicht gesetzt haben.

Claude Code teilt Claude mit, dass Ihre eigenen Anweisungen zur Zuordnung, wie eine CLAUDE.md oder [Memory](https://code.claude.com/docs/de/memory.md)-Regel, Vorrang vor diesen Commit- und PR-Zeilen haben, es sei denn, die Zeile ist in [verwalteten Einstellungen](https://code.claude.com/docs/de/managed-settings.md) gesetzt.

### `includeCoAuthoredBy`

> [!WARNING]
>
> Veraltet seit v2.0.62, als [`attribution`](#attribution) es ersetzte. Claude Code liest es immer noch, aber neue Konfigurationen sollten `attribution` setzen.

Verwenden Sie stattdessen [`attribution`](#attribution), das diesen Schlüssel ersetzt und es Ihnen ermöglicht, den Commit-Trailer, den Pull-Request-Text und den Sitzungslink separat zu ändern oder auszublenden. Claude Code respektiert immer noch `includeCoAuthoredBy: false` aus Einstellungsdateien, die `attribution` vorausgehen, ignoriert es aber, sobald Sie `attribution.commit` oder `attribution.pr` setzen.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: dasselbe wie nicht gesetzt; Claude Code fügt den Commit-Trailer und den Pull-Request-Zuordnungstext hinzu
  * `false`: Claude Code lässt sowohl den Commit-Trailer als auch den Pull-Request-Zuordnungstext weg, es sei denn, `attribution` setzt `commit` oder `pr`, in welchem Fall die [`attribution`](#attribution)-Regeln gelten
* **Standard**: `true`

```json settings.json theme={null}
{
  "includeCoAuthoredBy": false
}
```

Um alle Zuordnungen auszublenden, siehe [`attribution`](#attribution).

### `includeGitInstructions`

Claude Code gibt Claude zwei Git-bezogene Kontextteile: seine integrierten Anweisungen zum Schreiben von Commits und Pull Requests in der Bash-Tool-Beschreibung und einen Git-Status-Snapshot Ihres Repositorys. Der Snapshot enthält den aktuellen Branch, den Haupt-Branch, die Ausgabe von `git status` und aktuelle Commits. Claude Code liest ihn, wenn eine Konversation beginnt.

Setzen Sie diesen Schlüssel auf `false`, um beide auszulassen, zum Beispiel wenn Sie Ihre eigenen Git-Workflow-Skills verwenden.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code enthält seine integrierten Commit- und Pull-Request-Workflow-Anweisungen und den Git-Status-Snapshot. Cloud-Sitzungen enthalten niemals den Snapshot
  * `false`: Claude Code lässt beide aus
* **Standard**: `true`
* **Sitzungsspezifische Überschreibungen**: [`CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS`](https://code.claude.com/docs/de/env-vars) hat Vorrang vor diesem Schlüssel für eine Sitzung

```json settings.json theme={null}
{
  "includeGitInstructions": false
}
```

Wenn Sie den System-Prompt im [nicht interaktiven Modus](https://code.claude.com/docs/de/headless.md) oder im Agent SDK ersetzen, startet die Sitzung ohne den Snapshot, auch wenn dieser Schlüssel `true` ist:

* **`-p`-Ausführungen**: Sie ersetzen den Prompt, wenn Sie [`--system-prompt`](https://code.claude.com/docs/de/cli-reference#system-prompt-flags) oder `--system-prompt-file` übergeben. Sie ersetzen ihn auch, wenn Sie einen benutzerdefinierten Agenten mit eigenem Prompt ausführen, ausgewählt mit [`--agent`](https://code.claude.com/docs/de/sub-agents#invoke-subagents-explicitly) oder der Einstellung [`agent`](#agent). Um den Snapshot außerhalb des [Bare-Modus](https://code.claude.com/docs/de/headless.md#start-faster-with-bare-mode) beizubehalten, führen Sie die Sitzung ohne benutzerdefinierten Agenten aus und fügen Ihre Anweisungen mit [`--append-system-prompt`](https://code.claude.com/docs/de/cli-reference#system-prompt-flags) hinzu, anstatt den Prompt zu ersetzen.
* **[Agent SDK](https://code.claude.com/docs/de/agent-sdk/modifying-system-prompts.md)**: Sie ersetzen den Prompt durch einen benutzerdefinierten System-Prompt oder einen benutzerdefinierten Hauptthread-Agenten. Wenn Sie keinen System-Prompt festlegen, verwendet das SDK seinen minimalen Standard, und die Sitzung startet ebenfalls ohne den Snapshot. Um den Snapshot außerhalb des [Bare-Modus](https://code.claude.com/docs/de/headless.md#start-faster-with-bare-mode) beizubehalten, verwenden Sie das Preset `claude_code` ohne benutzerdefinierten `agent`.

### `prUrlTemplate`

Richten Sie die PR-Links, die Claude Code in der Fußzeilenbadge und in Tool-Ergebnis-Zusammenfassungen rendert, auf ein internes Code-Review-Tool statt auf `github.com` aus. Claude Code ersetzt `{host}`, `{owner}`, `{repo}`, `{number}` und `{url}` aus der PR-URL. [GitLab-Merge-Request](https://code.claude.com/docs/de/interactive-mode.md#gitlab-merge-requests)-Links auf beiden Oberflächen behalten ihre GitLab-URL.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Zeichenkette, eine URL-Vorlage mit einem der fünf Platzhalter
* **Standard**: nicht gesetzt

```json settings.json theme={null}
{
  "prUrlTemplate": "https://reviews.example.com/{owner}/{repo}/pull/{number}"
}
```

Claude Code wendet die Vorlage nur auf die Links an, die es selbst rendert; eine PR-Nummer, die Claude in einer Nachricht schreibt, wie `#123`, bleibt so, wie Claude sie geschrieben hat. Eine URL, die nicht die Form `/pull/<number>` hat, wird unverändert gelassen.

### `attribution.commit`

Legen Sie den Zuordnungstext fest, den Claude Code zu Git-Commits hinzufügt, einschließlich aller Trailer. Setzen Sie ihn auf eine leere Zeichenkette, um die Commit-Zuordnung auszublenden.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Zeichenkette
* **Standard**: nicht gesetzt, daher fügt Claude Code `Co-Authored-By: <name> <noreply@anthropic.com>` hinzu. Der Name ist das Modell, das beim Erstellen des Commits verwendet wird, wie `Claude Sonnet 5`. Wenn ein [Subagent](https://code.claude.com/docs/de/sub-agents.md) den Commit erstellt, nennt der Trailer das Modell des Subagenten.
  * Wenn Claude Code das Modell als Claude-Modell erkennt, aber seine genaue Version nicht bestätigen kann, schreibt es nur `Claude`.
  * Wenn es die Modell-ID nicht mit einem Claude-Modell abgleichen kann, wie ein Drittanbieter-Modell, das über eine benutzerdefinierte [`ANTHROPIC_BASE_URL`](https://code.claude.com/docs/de/env-vars) bereitgestellt wird, schreibt es `Claude Code`.

Dieses Beispiel ersetzt den Standard-Trailer durch eine benutzerdefinierte Zeile und einen benutzerdefinierten `Co-Authored-By`-Trailer:

```json settings.json theme={null}
{
  "attribution": {
    "commit": "Generated with AI\n\nCo-Authored-By: AI <ai@example.com>"
  }
}
```

### `attribution.pr`

Legen Sie den Zuordnungstext fest, den Claude Code zu Pull-Request-Beschreibungen hinzufügt. Setzen Sie ihn auf eine leere Zeichenkette, um die Pull-Request-Zuordnung auszublenden.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Zeichenkette
* **Standard**: nicht gesetzt, daher fügt Claude Code `🤖 Generated with [Claude Code](https://claude.com/claude-code)` hinzu

```json settings.json theme={null}
{
  "attribution": {
    "pr": ""
  }
}
```

### `attribution.sessionUrl`

Wählen Sie, ob Claude Code den claude.ai-Sitzungslink anhängt, wenn es von einer [Cloud](https://code.claude.com/docs/de/claude-code-on-the-web.md)- oder [Remote Control](https://code.claude.com/docs/de/remote-control.md)-Sitzung aus committet oder einen Pull Request öffnet. Claude Code fügt den Link als `Claude-Session`-Trailer bei Commits und als Link in Pull-Request-Beschreibungen hinzu. Setzen Sie ihn auf `false`, um den Link auszulassen.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code hängt den claude.ai-Sitzungslink an, wenn es von einer Cloud- oder Remote-Control-Sitzung aus committet oder einen Pull Request öffnet
  * `false`: Claude Code lässt den Link aus
* **Standard**: `true`

```json settings.json theme={null}
{
  "attribution": {
    "sessionUrl": false
  }
}
```

## Hooks und Automatisierung

Registrieren Sie Hooks, beschränken Sie, welche Hooks ausgeführt werden, und kontrollieren Sie Workflows. Für Hook-Ereignisse und Payloads siehe die [Hooks-Referenz](https://code.claude.com/docs/de/hooks.md).

### `allowedHttpHookUrls`

Begrenzen Sie, welche URLs [HTTP-Hooks](https://code.claude.com/docs/de/hooks.md#http-hook-fields) ansteuern können. Wenn Sie diesen Schlüssel definieren, führt Claude Code einen HTTP-Hook nur aus, wenn seine URL einem der Muster entspricht, und blockiert die übrigen ohne Ausführung; ein leeres Array blockiert jeden HTTP-Hook.

* **Bereich**: [`Any file`](#scopes). Arrays werden über Einstellungsdateien hinweg zusammengeführt.
* **Typ**: Array von URL-Mustern mit `*` als Platzhalter
* **Standard**: nicht gesetzt, daher ist jede URL zulässig

Dieses Beispiel erlaubt jede URL unter `https://hooks.example.com/` und jede `http://localhost`-URL:

```json settings.json theme={null}
{
  "allowedHttpHookUrls": ["https://hooks.example.com/*", "http://localhost:*"]
}
```

Der Hostname-Abgleich ist nicht case-sensitiv und behandelt `hooks.example.com.` mit dem nachgestellten Punkt, der einen vollständig qualifizierten Domänennamen kennzeichnet, genauso wie `hooks.example.com`, wie DNS es behandelt. Die Zulassungsliste gilt für Hooks aus jeder Quelle, einschließlich verwalteter Einstellungen.

In der Option `managedSettings` des Agent SDK ignoriert Claude Code eine Liste mit Einträgen; übergeben Sie sie daher stattdessen in der [Option `settings`](https://code.claude.com/docs/de/agent-sdk/typescript#options) des SDK. Siehe [was eine leere Liste in übergeordneten Einstellungen bewirkt](https://code.claude.com/docs/de/claude-apps-gateway#how-hook-and-skill-keys-in-parent-settings-take-effect).

### `allowManagedHooksOnly`

Beschränken Sie die Hook-Ausführung auf Hooks, die Ihre Organisation bereitstellt.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Boolean
  * `true`: nur verwaltete Hooks werden ausgeführt, plus Agent SDK Hooks und Hooks aus Plugins, die Ihre verwalteten Einstellungen erzwingen. Siehe [Was wird unter `allowManagedHooksOnly` ausgeführt](#what-runs-under-allowmanagedhooksonly)
  * `false`: Hooks aus jedem Einstellungsbereich und Plugin werden ausgeführt
* **Standard**: nicht gesetzt, daher werden Hooks aus jedem Einstellungsbereich und Plugin ausgeführt

```json managed-settings.json theme={null}
{
  "allowManagedHooksOnly": true
}
```

#### Was wird unter `allowManagedHooksOnly` ausgeführt

Wenn Sie es auf `true` setzen, ändert Claude Code, welche Hooks und Hook-ähnliche Befehle geladen werden:

* **Verwaltete und SDK-Hooks werden ausgeführt**: Hooks aus verwalteten Einstellungen und Hooks, die das [Agent SDK](https://code.claude.com/docs/de/agent-sdk/overview.md) im Prozess registriert
* **Erzwungene Plugin-Hooks werden ausgeführt**: Hooks aus Plugins, die Ihre verwalteten Einstellungen durch [`enabledPlugins`](#enabledplugins) erzwingen. Claude Code gleicht die vollständige `plugin@marketplace`-ID ab, daher bleibt ein Plugin mit demselben Namen aus einem anderen Marketplace blockiert. Dies ermöglicht es Ihnen, überprüfte Hooks über einen Organisations-Marketplace zu verteilen und alles andere zu blockieren. Ein [Mod](https://code.claude.com/docs/de/plugins/mods/overview.md) in einem solchen Plugin wird nur geladen, wenn er [als Mod Ihrer Organisation gilt](https://code.claude.com/docs/de/plugins/mods/admin.md#install-your-organizations-mods)
* **Monitore aus anderen Plugins werden blockiert**: Die [Monitore](https://code.claude.com/docs/de/plugins/components.md#monitors) eines Plugins starten nur, wenn das Plugin erzwungen aktiviert ist. Erfordert Claude Code v2.1.310 oder später
* **Alles andere wird blockiert**: Benutzer-, Projekt- und lokale Hooks, Hooks und Mods aus anderen installierten Plugins sowie Hooks, die im Agent-Frontmatter deklariert sind. [In Claude Code integrierte Mods](https://code.claude.com/docs/de/plugins/mods/overview.md#mods-built-into-claude-code) werden weiterhin ausgeführt. Um nur die Mods der Benutzer zu blockieren, setzen Sie stattdessen [`allowManagedModsOnly`](https://code.claude.com/docs/de/plugins/mods/admin#set-options-on-the-built-in-guard).
* **Command-sourced Plugins sind deaktiviert**: Claude Code deaktiviert auch Plugins mit einer [`command`-Quelle](https://code.claude.com/docs/de/plugins/marketplace-reference#command-plugin-source), einschließlich Plugins, die in verwalteten `enabledPlugins` erzwungen werden, es sei denn, Sie setzen [`disableCommandPluginSources`](#disablecommandpluginsources) explizit auf `false`
* **Marketplace `headersHelper`-Befehle werden blockiert**: Claude Code blockiert auch Marketplace-[`headersHelper`-Befehle](https://code.claude.com/docs/de/plugins/host-marketplace#authenticate-archive-downloads), es sei denn, [`disableCommandPluginSources`](#disablecommandpluginsources) ist explizit auf `false` gesetzt, außer für einen Marketplace, den die verwalteten Einstellungen selbst deklarieren. Erfordert Claude Code v2.1.238 oder später
* **Statuszeile und Dateivorschlag werden auf verwaltete Einstellungen beschränkt**: Claude Code liest [`statusLine`](https://code.claude.com/docs/de/statusline), [`fileSuggestion`](#filesuggestion) und [`subagentStatusLine`](https://code.claude.com/docs/de/statusline#subagent-status-lines) nur aus verwalteten Einstellungen, gemäß den [Statuszeilen- und Dateivorschlag-Gates](#status-line-and-file-suggestion-gates)

Der [`/goal`](https://code.claude.com/docs/de/goal)-Befehl kann nicht ausgeführt werden, während dieser Schlüssel gesetzt ist, da er von Hooks abhängt.

### `disableAllHooks`

Schalten Sie [Hooks](https://code.claude.com/docs/de/hooks.md#disable-or-remove-hooks), jede benutzerdefinierte [Statuszeile](https://code.claude.com/docs/de/statusline.md) und jeden benutzerdefinierten [Dateivorschlag](#filesuggestion)-Befehl aus. Verwenden Sie dies, um alle diese vorübergehend auszuschalten, ohne sie aus Ihren Einstellungen zu löschen.

* **Bereich**: [`Any file`](#scopes). Nur verwaltete Einstellungen können verwaltete Hooks deaktivieren.
* **Typ**: Boolean
  * `true`: Claude Code schaltet Hooks, jede benutzerdefinierte Statuszeile und jeden benutzerdefinierten Dateivorschlag-Befehl aus
  * `false`: Hooks, die Statuszeile und der Dateivorschlag-Befehl werden ausgeführt
* **Standard**: nicht gesetzt, daher werden Hooks ausgeführt

```json settings.json theme={null}
{
  "disableAllHooks": true
}
```

Die Reichweite hängt davon ab, welche Datei den Schlüssel trägt:

* **In verwalteten Einstellungen**: Claude Code deaktiviert jeden konfigurierten Hook, einschließlich verwalteter, und führt weiterhin die Hooks aus, die das [Agent SDK](https://code.claude.com/docs/de/agent-sdk/overview.md) im Prozess registriert
* **In der Option `managedSettings` des Agent SDK**: Auf einem Rechner, auf dem ein Administrator verwaltete Einstellungen bereitstellt, ignoriert Claude Code diesen Schlüssel, es sei denn, der Administrator [erlaubt einem einbettenden Host, Richtlinien hinzuzufügen](https://code.claude.com/docs/de/managed-settings.md#let-an-embedding-host-add-policy). Wo der Schlüssel wirksam wird, werden Benutzer-, Projekt-, lokale und Plugin-Hooks gestoppt, ebenso alle Hooks in der Option `settings` des SDK. Die verwalteten Hooks eines Administrators, die Hooks [erzwungen aktivierter](#enabledplugins) Plugins und Ihre [SDK-Hook-Callbacks](https://code.claude.com/docs/de/agent-sdk/hooks.md) werden weiterhin ausgeführt. Erfordert Claude Code v2.1.309 oder später.
* **In jeder anderen Einstellungsdatei**: Claude Code deaktiviert Benutzer-, Projekt-, lokale und Plugin-Hooks; verwaltete Hooks, Agent SDK Hooks und Hooks aus Plugins, die in verwalteten [`enabledPlugins`](#enabledplugins) erzwungen werden, werden weiterhin ausgeführt

Der Schlüssel stoppt auch [Mods](https://code.claude.com/docs/de/plugins/mods/overview.md), also Plugins, deren Code Hooks registriert:

* **In verwalteten Einstellungen**: Die Mods in jedem installierten Plugin werden gestoppt, einschließlich der Mods Ihrer Organisation
* **In jeder anderen Einstellungsdatei**: Die von Ihnen installierten Mods werden gestoppt, und [die Mods Ihrer Organisation](https://code.claude.com/docs/de/plugins/mods/admin.md#install-your-organizations-mods) werden weiterhin ausgeführt

In Claude Code integrierte Mods werden in beiden Fällen weiterhin ausgeführt. Jeder hat [einen eigenen Schalter](https://code.claude.com/docs/de/plugins/mods/overview.md#mods-built-into-claude-code).

Das Beibehalten von Agent SDK Hooks, wenn verwaltete Einstellungen diesen Schlüssel setzen, erfordert Claude Code v2.1.242 oder später.

Der [`/goal`](https://code.claude.com/docs/de/goal)-Befehl kann nicht ausgeführt werden, während Hooks deaktiviert sind, und das `/hooks`-Menü zeigt stattdessen einen Hinweis anstelle Ihrer Hooks.

#### Statuszeilen- und Dateivorschlag-Gates

Claude Code trifft zwei Entscheidungen für `statusLine`, `fileSuggestion` und `subagentStatusLine` in dieser Reihenfolge:

* **Vollständig ausgeschaltet**: wenn verwaltete Einstellungen `disableAllHooks` setzen, oder wenn der Ordner nicht vertraut wird gemäß der gleichen [Workspace-Vertrauensregel wie Hooks in Einstellungsdateien](https://code.claude.com/docs/de/permissions.md#what-runs-before-you-trust-a-folder)
* **Auf verwaltete Einstellungen beschränkt**: wenn [`allowManagedHooksOnly`](#allowmanagedhooksonly) gesetzt ist, wenn `disableAllHooks` außerhalb verwalteter Einstellungen nach Anwendung der [Einstellungspriorität](https://code.claude.com/docs/de/hooks.md#disable-or-remove-hooks) `true` ist, oder wenn Sie Claude Code mit `--safe-mode` starten

Bei Beschränkung führt Claude Code einen verwalteten Wert aus, wenn einer bereitgestellt wird. Andernfalls überspringt es Ihren Wert ohne Warnung: die Statuszeile ist deaktiviert und die `@`-Autovervollständigung fällt auf den integrierten Dateivorschlag zurück.

### `disableWorkflows`

Schalten Sie [dynamische Workflows](https://code.claude.com/docs/de/workflows.md#turn-workflows-off) und die gebündelten Workflow-Befehle für alle aus, die Ihre Einstellungen erreichen, z. B. eine Organisation über verwaltete Einstellungen. Um Workflows nur für sich selbst ein- oder auszuschalten, verwenden Sie stattdessen [`enableWorkflows`](#enableworkflows), das der Schalter **Dynamic workflows** in `/config` in Ihre Benutzereinstellungen schreibt.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code schaltet dynamische Workflows und die gebündelten Workflow-Befehle für alle aus, die Ihre Einstellungen erreichen
  * `false`: dasselbe wie nicht gesetzt; ob Workflows dann aktiviert sind, folgt [`enableWorkflows`](#enableworkflows) und dem Standard Ihres Plans
* **Standard**: `false`
* **Pro-Session-Überschreibungen**: [`CLAUDE_CODE_DISABLE_WORKFLOWS`](https://code.claude.com/docs/de/env-vars) schaltet Workflows für eine Sitzung aus; welcher der beiden sie ausschaltet, der andere kann sie nicht wieder einschalten

```json settings.json theme={null}
{
  "disableWorkflows": true
}
```

### `enableWorkflows`

Schalten Sie [dynamische Workflows](https://code.claude.com/docs/de/workflows.md) für sich selbst ein oder aus, wenn der Standard Ihres Plans nicht das ist, was Sie möchten. Erscheint in `/config` als **Dynamic workflows**, das diesen Schlüssel in Ihre Benutzereinstellungen schreibt und ihn wieder entfernt, wenn Sie zurück zu Ihrem Plan-Standard umschalten. Um Workflows für alle aus verwalteten Einstellungen auszuschalten, verwenden Sie stattdessen [`disableWorkflows`](#disableworkflows).

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code schaltet dynamische Workflows für Sie ein
  * `false`: Claude Code schaltet dynamische Workflows für Sie aus
* **Standard**: nicht gesetzt, daher sind Workflows aktiviert, es sei denn, Sie sind im Pro-Plan, wo sie deaktiviert sind
* **Pro-Session-Überschreibungen**: [`CLAUDE_CODE_DISABLE_WORKFLOWS`](https://code.claude.com/docs/de/env-vars) schaltet Workflows für eine Sitzung aus, und `true` hier kann sie nicht wieder einschalten, während es gesetzt ist

```json settings.json theme={null}
{
  "enableWorkflows": true
}
```

[`disableWorkflows`](#disableworkflows) und die Workflows-Richtlinie Ihrer Organisation haben auch Vorrang: `enableWorkflows: true` kann Workflows nicht wieder einschalten, während eine Quelle Workflows ausschaltet. Claude Code verbirgt die `/config`-Zeile, während eine andere Quelle als Ihre Benutzereinstellungen `enableWorkflows` setzt oder `disableWorkflows` auf `true` setzt.

### `hooks`

Führen Sie Ihre eigenen Befehle, Prompts, Agenten, HTTP-Anfragen oder MCP-Tools als [Hooks](https://code.claude.com/docs/de/hooks.md) an Punkten im Lebenszyklus von Claude Code aus, z. B. vor einem Tool-Aufruf oder wenn eine Sitzung startet; die [Hooks-Referenz](https://code.claude.com/docs/de/hooks.md#hook-events) listet jedes Ereignis, seine Payload und seine Exit-Codes auf. Jedes Ereignis wird einer Liste von Matcher-Gruppen zugeordnet, und jede Gruppe listet die Handler auf, die ausgeführt werden, wenn der Matcher zutrifft.

* **Bereich**: [`Any file`](#scopes). Hooks werden über Dateien hinweg zusammengeführt, anstatt sich gegenseitig zu ersetzen, und Hooks aus verwalteten Einstellungen können nicht aus anderen Dateien entfernt werden.
* **Typ**: Objekt mit einem Schlüssel pro [Hook-Ereignis](https://code.claude.com/docs/de/hooks.md#hook-events); jeder Wert ist ein Array von `{ "matcher", "hooks" }`-Gruppen, deren `hooks`-Einträge einen `type` von `"command"`, `"prompt"`, `"agent"`, `"http"` oder `"mcp_tool"` haben
* **Standard**: nicht gesetzt, daher werden keine Hooks ausgeführt

Dieses Beispiel führt ein Skript vor jedem Bash-Tool-Aufruf aus:

```json settings.json theme={null}
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "~/.claude/hooks/check-bash.sh" }
        ]
      }
    ]
  }
}
```

Für jedes Ereignis, Matcher-Muster und Handler-Feld siehe die [Hooks-Referenz](https://code.claude.com/docs/de/hooks.md#configuration). Um Hooks auszuschalten, siehe [`disableAllHooks`](#disableallhooks); um Hooks auf die zu beschränken, die Ihre Organisation bereitstellt, siehe [`allowManagedHooksOnly`](#allowmanagedhooksonly).

### `httpHookAllowedEnvVars`

Ein [HTTP-Hook](https://code.claude.com/docs/de/hooks.md#http-hook-fields) kann den Wert einer Umgebungsvariablen in einen Request-Header einfügen, z. B. einen `Authorization: Bearer $HOOK_TOKEN`-Header, aber nur für Variablen, die der Hook in seinem eigenen `allowedEnvVars` auflistet. Dieser Schlüssel setzt eine äußere Grenze für diese Liste für jeden HTTP-Hook: Ein Hook kann eine Variable nur verwenden, wenn sowohl sein eigenes `allowedEnvVars` als auch dieser Schlüssel sie benennen. Verwenden Sie dies, um zu verhindern, dass ein Hook ein Geheimnis liest, das es nicht sollte, auch wenn die Hook-Definition danach fragt.

* **Bereich**: [`Any file`](#scopes). Arrays werden über Einstellungsdateien hinweg zusammengeführt.
* **Typ**: Array von Umgebungsvariablennamen
* **Standard**: nicht gesetzt, daher gilt die `allowedEnvVars`-Liste jedes Hooks

Dieses Beispiel begrenzt die Header-Interpolation auf `MY_TOKEN` und `HOOK_SECRET`:

```json settings.json theme={null}
{
  "httpHookAllowedEnvVars": ["MY_TOKEN", "HOOK_SECRET"]
}
```

Die Zulassungsliste gilt für Hooks aus jeder Quelle, einschließlich verwalteter Einstellungen.

In der Option `managedSettings` des Agent SDK ignoriert Claude Code eine Liste mit Einträgen; übergeben Sie sie daher stattdessen in der [Option `settings`](https://code.claude.com/docs/de/agent-sdk/typescript#options) des SDK. Siehe [was eine leere Liste in übergeordneten Einstellungen bewirkt](https://code.claude.com/docs/de/claude-apps-gateway#how-hook-and-skill-keys-in-parent-settings-take-effect).

### `workflowKeywordTriggerEnabled`

Wählen Sie, ob die Eingabe des Schlüsselworts `ultracode` in einem Prompt einen [dynamischen Workflow](https://code.claude.com/docs/de/workflows.md#ask-for-a-workflow-in-your-prompt) auslöst. Setzen Sie es auf `false`, um das Wort einzugeben, ohne einen auszulösen.

* **Bereich**: [`Any file`](#scopes). Erscheint in `/config` als **Ultracode keyword trigger**.
* **Typ**: Boolean
  * `true`: Die Eingabe von `ultracode` in einem Prompt löst einen dynamischen Workflow aus
  * `false`: Sie können das Wort eingeben, ohne einen auszulösen
* **Standard**: `true`

```json settings.json theme={null}
{
  "workflowKeywordTriggerEnabled": false
}
```

Die `ultracode`-Aufwandseinstellung, `/workflows` und gespeicherte Workflow-Befehle sind nicht betroffen.

### `workflowSizeGuideline`

Legen Sie die [Agentenzahl fest, auf die Claude abzielt](https://code.claude.com/docs/de/workflows.md#set-a-size-guideline) in den dynamischen Workflows, die es schreibt. Claude Code sendet den Wert an Claude als Ratschlag, nicht als erzwungene Obergrenze: `"small"` fordert weniger als 5 Agenten an, `"medium"` weniger als 10 und `"large"` weniger als 50. Wählen Sie `"small"`, wenn Sie begrenzen möchten, was ein Workflow ausgibt. Erfordert Claude Code v2.1.219 oder später.

* **Bereich**: [`Any file`](#scopes). Ein Wert dort hat Vorrang vor der Auswahl **Dynamic workflow size** in `/config`, die Claude Code in `~/.claude.json` speichert, und Claude Code verbirgt diese Zeile, während eine Einstellungsdatei den Schlüssel setzt.
* **Typ**: String, einer von:
  * `"unrestricted"`: keine Richtlinie, daher passt Claude den Workflow an die Aufgabe an
  * `"small"`: Claude zielt auf weniger als 5 Agenten ab
  * `"medium"`: Claude zielt auf weniger als 10 Agenten ab
  * `"large"`: Claude zielt auf weniger als 50 Agenten ab
* **Standard**: `"medium"`, oder `"small"` wenn Sie im Pro-Plan mit Claude Code v2.1.271 oder später angemeldet sind

```json settings.json theme={null}
{
  "workflowSizeGuideline": "small"
}
```

Erfordert Claude Code v2.1.219 oder später; auf v2.1.202 bis v2.1.218 legen Sie die Richtlinie stattdessen in `/config` fest.

## Plugins und Skills

Aktivieren Sie Plugins, registrieren Sie Marketplaces, beschränken Sie, welche Plugin-Quellen eine Organisation zulässt, und kontrollieren Sie, welche Skills geladen werden. Informationen zum Installieren und Erstellen von Plugins finden Sie unter [Plugins](https://code.claude.com/docs/de/plugins/overview.md).

### `disableBundledSkills`

Deaktivieren Sie die [Skills](https://code.claude.com/docs/de/skills.md) und Workflows, die in Claude Code enthalten sind. Claude Code entfernt gebündelte Skills und Workflows vollständig, während integrierte Befehle wie `/init` eingegeben werden können, aber vom Modell verborgen sind.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code entfernt gebündelte Skills und Workflows und verbirgt integrierte Befehle wie `/init` vor dem Modell
  * `false`: gebündelte Skills werden geladen
* **Standard**: nicht gesetzt, daher werden gebündelte Skills geladen
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_DISABLE_BUNDLED_SKILLS`](https://code.claude.com/docs/de/env-vars) auf `1` gesetzt deaktiviert gebündelte Skills für eine Sitzung; welcher der beiden sie deaktiviert, der andere kann sie nicht wieder aktivieren

```json settings.json theme={null}
{
  "disableBundledSkills": true
}
```

Skills von Plugins, `.claude/skills/` und `.claude/commands/` sind nicht betroffen. `/doctor` kann wie die integrierten Befehle eingegeben werden; um ihn zu verbergen, setzen Sie stattdessen [`DISABLE_DOCTOR_COMMAND`](https://code.claude.com/docs/de/env-vars).

### `disableSkillShellExecution`

Deaktivieren Sie die Inline-Shell-Ausführung für `` !`...` ``- und ` ```! `-Blöcke in [Skills](https://code.claude.com/docs/de/skills.md) und benutzerdefinierten Befehlen aus Benutzer-, Projekt-, Plugin- oder zusätzlichen Verzeichnisquellen. Claude Code ersetzt jeden Befehl durch `[shell command execution disabled by policy]`, statt ihn auszuführen.

* **Bereich**: [`Any file`](#scopes). Ein `true` in verwalteten Einstellungen kann nicht durch `false` an anderer Stelle überschrieben werden.
* **Typ**: Boolean
  * `true`: Claude Code ersetzt jeden Inline-Shell-Befehl durch `[shell command execution disabled by policy]` statt ihn auszuführen
  * `false`: Inline-Shell wird ausgeführt
* **Standard**: nicht gesetzt, daher wird Inline-Shell ausgeführt

```json settings.json theme={null}
{
  "disableSkillShellExecution": true
}
```

Gebündelte Skills und Skills, die über verwaltete Einstellungen bereitgestellt werden, sind nicht betroffen.

### `skillOverrides`

Verbergen oder reduzieren Sie einen [Skill](https://code.claude.com/docs/de/skills.md#override-skill-visibility-from-settings) ohne dessen `SKILL.md` zu bearbeiten. Claude Code wendet den Wert unter jedem Skill-Namen auf die Skill-Liste an, die Claude sieht, und auf Ihre `/` Autovervollständigung.

* **Bereich**: [`Any file`](#scopes). Das `/skills` Menü schreibt in `.claude/settings.local.json`.
* **Typ**: Objekt, das Skill-Namen auf einen der folgenden Werte abbildet:
  * `"on"`: Claude sieht den Skill und Sie können `/name` eingeben
  * `"name-only"`: Claude sieht den Skill nur nach Name ohne seine Beschreibung
  * `"user-invocable-only"`: Claude sieht den Skill nicht, aber Sie können immer noch `/name` eingeben
  * `"off"`: Claude sieht den Skill nicht und `/name` ist in der Autovervollständigung verborgen
* **Standard**: nicht gesetzt, daher ist jeder Skill `"on"`

Dieses Beispiel listet `legacy-context` für Claude nur nach Name auf und verbirgt `deploy` vor Claude und vor der `/` Autovervollständigung:

```json settings.json theme={null}
{
  "skillOverrides": {
    "legacy-context": "name-only",
    "deploy": "off"
  }
}
```

Überschreibungen gelten nicht für Plugin-Skills, die Sie über `/plugin` verwalten.

In verwalteten Einstellungen und Dateien, die mit `--settings` übergeben werden, gilt ein Schlüssel auf einem Alias eines gebündelten Skills, wie `checkup` für `/doctor`, auch für den Skill; siehe [wie Alias-Schlüssel mit Schlüsseln auf dem eigenen Namen des Skills kombiniert werden](https://code.claude.com/docs/de/skills.md#override-skill-visibility-from-settings).

### `syncClaudeAiSkills`

Deaktivieren Sie den Download der [Skills, die für Ihr claude.ai-Konto aktiviert sind](https://code.claude.com/docs/de/skills.md#how-synced-skills-behave). Claude Code lädt sie in `~/.claude/skills/synced/` in [Terminalsitzungen herunter, in denen Sie sich mit Ihrem claude.ai-Konto anmelden](https://code.claude.com/docs/de/skills.md#where-synced-skills-load), interaktiv oder nicht-interaktiv, und in Cowork- und Cloud-Sitzungen. Setzen Sie `false`, um diesen Download zu stoppen und das Laden der bereits synchronisierten Skills zu beenden. Claude Code berücksichtigt nur `false`: `true` ist dasselbe wie nicht gesetzt und aktiviert die Synchronisierung nicht, wo sie sonst deaktiviert ist.

* **Bereich**: [`User, local, or managed`](#scopes) und Dateien, die mit `--settings` übergeben werden. Ein Repository kann es für Sie nicht deaktivieren.
* **Typ**: Boolean
  * `false`: Claude Code stoppt das Herunterladen synchronisierter Skills und stoppt das Laden der bereits in `~/.claude/skills/synced/` vorhandenen. In Benutzer- oder verwalteten Einstellungen verschiebt es sie auch in `~/.claude/skills/.trash/`
  * `true`: dasselbe wie nicht gesetzt
* **Standard**: nicht gesetzt, daher synchronisieren Sitzungen, die mit Ihrem claude.ai-Konto angemeldet sind, Ihre Skills

Dieses Beispiel verhindert, dass ein Computer die Skills des Kontos in einer beliebigen Sitzung herunterlädt:

```json settings.json theme={null}
{
  "syncClaudeAiSkills": false
}
```

### `syncClaudeAiPlugins`

Deaktivieren Sie den Download der [Plugins, die für Ihr claude.ai-Konto aktiviert sind](https://code.claude.com/docs/de/plugins/loading.md#synced-plugins). Claude Code lädt sie in `~/.claude/plugins/synced/` am Anfang von Terminalsitzungen herunter, in denen Sie sich mit Ihrem claude.ai-Konto anmelden, und in Cowork-Sitzungen, und lädt jedes als `<name>@synced`. Setzen Sie `false`, um diesen Download zu stoppen und das Laden der bereits synchronisierten Plugins zu beenden. Claude Code berücksichtigt nur `false`: `true` ist dasselbe wie nicht gesetzt und aktiviert die Synchronisierung nicht, wo sie sonst deaktiviert ist. Erfordert Claude Code v2.1.273 oder später.

* **Bereich**: [`User, local, or managed`](#scopes) und Dateien, die mit `--settings` übergeben werden. Ein Repository kann es für Sie nicht deaktivieren.
* **Typ**: Boolean
  * `false`: Claude Code stoppt das Herunterladen synchronisierter Plugins und stoppt das Laden der bereits in `~/.claude/plugins/synced/` vorhandenen. In Benutzer- oder verwalteten Einstellungen verschiebt es sie auch in `~/.claude/plugins/.trash/`
  * `true`: dasselbe wie nicht gesetzt
* **Standard**: nicht gesetzt, daher synchronisieren Sitzungen, die mit Ihrem claude.ai-Konto angemeldet sind, Ihre Plugins

Um ein synchronisiertes Plugin auszuschalten, anstatt alle, setzen Sie `"<name>@synced": false` in [`enabledPlugins`](#enabledplugins).

Dieses Beispiel verhindert, dass ein Computer die Plugins des Kontos in einer beliebigen Sitzung herunterlädt:

```json settings.json theme={null}
{
  "syncClaudeAiPlugins": false
}
```

### `allowedChannelPlugins`

Wählen Sie, welche [Kanal](https://code.claude.com/docs/de/channels.md)-Plugins Nachrichten in Sitzungen in Ihrer Organisation pushen können. Wenn Sie es festlegen, verwendet Claude Code Ihre Liste anstelle der Standard-Anthropic-Zulassungsliste; jeder Eintrag benennt ein Plugin und den Marketplace, aus dem es stammt.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Array von Objekten, jeweils mit `marketplace` und `plugin` Strings. Ein Eintrag kann stattdessen ein `"plugin@marketplace"` String wie `"telegram@claude-plugins-official"` sein, den Claude Code als das äquivalente Objekt behandelt. Die String-Form erfordert Claude Code v2.1.267 oder später; frühere Versionen lehnen den gesamten `allowedChannelPlugins` Wert ab, wenn er einen enthält
* **Standard**: nicht gesetzt, daher verwendet Claude Code die Standard-Anthropic-Zulassungsliste

Dieses Beispiel aktiviert Kanäle und erlaubt nur das Telegram-Plugin aus dem offiziellen Anthropic-Marketplace:

```json managed-settings.json theme={null}
{
  "channelsEnabled": true,
  "allowedChannelPlugins": [
    { "marketplace": "claude-plugins-official", "plugin": "telegram" }
  ]
}
```

Ein leeres Array blockiert jedes Kanal-Plugin.

Dieser Schlüssel wird wirksam, sobald Kanäle das [`channelsEnabled`](#channelsenabled) Gate für das Konto passieren: auf Team- und Enterprise-Plänen und auf Console-Konten mit verwalteten Einstellungen bedeutet das `channelsEnabled: true`. Siehe [Beschränken Sie, welche Kanal-Plugins ausgeführt werden können](https://code.claude.com/docs/de/channels.md#restrict-which-channel-plugins-can-run).

### `blockedMarketplaces`

Blockieren Sie Plugin-Marketplace-Quellen für Ihre Organisation. Claude Code überprüft die Blockliste beim Hinzufügen von Marketplace und beim Installieren, Aktualisieren, Aktualisieren und automatischen Aktualisieren von Plugins, daher kann ein Marketplace, den jemand hinzugefügt hat, bevor Sie die Richtlinie festgelegt haben, nicht zum Abrufen von Plugins verwendet werden. Blockierte Quellen werden vor dem Download überprüft, daher berühren sie niemals das Dateisystem.

Wenn Sie diesen Schlüssel in der [claude.ai Admin-Konsole](https://code.claude.com/docs/de/server-managed-settings.md) festlegen, wendet claude.ai ihn auch an, wenn jemand in Ihrer Organisation einen Marketplace aus einem Git-Repository auf claude.ai hinzufügt, wie [Wie Einschränkungen funktionieren](https://code.claude.com/docs/de/plugins/org.md#restrict-what-users-can-install) beschreibt.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Array von Marketplace-Quellobjekten in denselben Formen wie [`strictKnownMarketplaces`](#allowed-source-types)
* **Standard**: nicht gesetzt, daher ist kein Marketplace blockiert

Dieses Beispiel blockiert ein GitHub-Repository als Marketplace-Quelle:

```json managed-settings.json theme={null}
{
  "blockedMarketplaces": [
    { "source": "github", "repo": "untrusted/plugins" }
  ]
}
```

Ein `github` Eintrag kann die [Owner-Wildcard-Form](#owner-wildcards) `"owner/*"` verwenden, um jedes Repository unter diesem GitHub-Owner zu blockieren, was Claude Code v2.1.223 oder später erfordert. Fügen Sie `{ "source": "skills-dir" }` hinzu, um Claude Code daran zu hindern, [`@skills-dir` Plugins](https://code.claude.com/docs/de/plugins/loading#plugins-shared-through-a-repository) sowohl aus `~/.claude/skills/` als auch aus dem `.claude/skills/` eines Projekts zu laden, ohne einen Marketplace einzuschränken. Siehe [Verwaltete Marketplace-Einschränkungen](https://code.claude.com/docs/de/plugins/org.md#restrict-what-users-can-install).

### `channelsEnabled`

Erlauben Sie [Kanäle](https://code.claude.com/docs/de/channels.md) für Ihre Organisation. Bei claude.ai Team- und Enterprise-Plänen blockiert Claude Code Kanäle, bis Sie dies auf `true` setzen. Für [Anthropic Console](https://code.claude.com/docs/de/authentication.md#claude-console-authentication) Konten, die sich mit einem API-Schlüssel authentifizieren, sind Kanäle standardmäßig zulässig. Wenn Ihre Organisation verwaltete Einstellungen bereitstellt, blockiert Claude Code Kanäle auf diesen Konten auch, bis Sie diesen Schlüssel auf `true` setzen.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code erlaubt Kanäle für Ihre Organisation
  * `false`: dasselbe wie nicht gesetzt; ob Kanäle blockiert sind, hängt von Ihrem Plan ab, wie der Standard sagt
* **Standard**: nicht gesetzt; Kanäle sind auf Team- und Enterprise-Plänen und auf Console-Konten mit verwalteten Einstellungen blockiert und auf Pro- und Max-Plänen und auf Console-Konten ohne verwaltete Einstellungen zulässig

```json managed-settings.json theme={null}
{
  "channelsEnabled": true
}
```

Um einzuschränken, welche Plugins sich als Kanäle registrieren können, sobald sie aktiviert sind, setzen Sie [`allowedChannelPlugins`](#allowedchannelplugins). Siehe [Enterprise-Kontrollen](https://code.claude.com/docs/de/channels.md#enterprise-controls).

### `disableCommandPluginSources`

Blockieren Sie die [`command` Plugin-Quelle](https://code.claude.com/docs/de/plugins/marketplace-reference#command-plugin-source), die ein Plugin durch Ausführung eines von Marketplace deklarierten Befehls auf dem Computer des Benutzers installiert. Wenn Sie es auf `true` setzen, führt Claude Code den Befehl niemals aus, installiert oder aktualisiert keine Befehls-Quellen-Plugins und stoppt das Laden der bereits installierten. Setzen Sie es auf `false`, um sie explizit zuzulassen. Wann immer es Befehlsquellen blockiert, ob Sie es auf `true` setzen oder es unter [`allowManagedHooksOnly`](#allowmanagedhooksonly) nicht gesetzt lassen, blockiert es auch Marketplace [`headersHelper` Befehle](https://code.claude.com/docs/de/plugins/host-marketplace#authenticate-archive-downloads), außer für einen Marketplace, den verwaltete Einstellungen selbst deklarieren. Erfordert Claude Code v2.1.229 oder später, und der `headersHelper` Block erfordert v2.1.238 oder später.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code führt den von Marketplace deklarierten Befehl niemals aus, installiert oder aktualisiert keine Befehls-Quellen-Plugins und stoppt das Laden der bereits installierten
  * `false`: Claude Code erlaubt Befehls-Quellen-Plugins explizit
* **Standard**: nicht gesetzt, daher folgt Claude Code [`allowManagedHooksOnly`](#allowmanagedhooksonly): eine Organisation, die die Hook-Ausführung auf verwaltete Einstellungen beschränkt, bekommt auch Befehlsquellen deaktiviert. Eine Anwendung, die [`disableAllHooks: true`](#disableallhooks) in der Option `managedSettings` des Agent SDK übergibt, deaktiviert Befehlsquellen dadurch allein nicht.

```json managed-settings.json theme={null}
{
  "disableCommandPluginSources": true
}
```

Erfordert Claude Code v2.1.229 oder später.

### `pluginSuggestionMarketplaces`

Benennen Sie die Marketplaces, deren Plugins als kontextuelle Installationsvorschläge erscheinen können, in Spinner-Tipps und oben im `/plugin` **Discover** Tab angeheftet. Der integrierte First-Party-Frontend-Design-Tipp ist nicht betroffen. Vorschläge stammen aus der `relevance` Deklaration jedes Plugins in seinem Marketplace-Eintrag.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Array von Marketplace-Namen
* **Standard**: nicht gesetzt, daher werden keine von Marketplace deklarierten Vorschläge angezeigt

```json managed-settings.json theme={null}
{
  "pluginSuggestionMarketplaces": ["acme-corp-plugins"]
}
```

Ein Name wird nur wirksam, wenn der Marketplace auf dem Computer registriert ist und seine registrierte Quelle auch in denselben verwalteten Einstellungen deklariert ist, entweder als [`extraKnownMarketplaces`](#extraknownmarketplaces) Eintrag für diesen Namen oder als Eintrag von [`strictKnownMarketplaces`](#strictknownmarketplaces). Claude Code ignoriert einen Marketplace, der von einer anderen Quelle unter einem zulässigen Namen registriert ist. Der offizielle Marketplace ist von der Quellanforderung befreit: das Zulassen seines Namens allein genügt, da dieser Name nur von der offiziellen Anthropic-Quelle registriert werden kann. Siehe [Plugins nach Kontext vorschlagen](https://code.claude.com/docs/de/plugins/relevance.md).

### `pluginTrustMessage`

Fügen Sie den eigenen Text Ihrer Organisation zur Plugin-Vertrauenswarnung hinzu, die Claude Code vor der Installation anzeigt, um beispielsweise zu bestätigen, dass Plugins aus Ihrem internen Marketplace überprüft werden.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: String
* **Standard**: nicht gesetzt, daher zeigt Claude Code nur die Standardwarnung an

```json managed-settings.json theme={null}
{
  "pluginTrustMessage": "All plugins from our marketplace are approved by IT"
}
```

### `strictKnownMarketplaces`

Beschränken Sie, welche Plugin-Marketplace-Quellen Personen in Ihrer Organisation hinzufügen und Plugins installieren können. Claude Code erzwingt die Zulassungsliste beim Hinzufügen von Marketplace und beim Installieren, Aktualisieren, Aktualisieren und automatischen Aktualisieren von Plugins, vor jeder Netzwerk- oder Dateisystemoperation, daher kann ein Marketplace, den jemand hinzugefügt hat, bevor Sie die Richtlinie festgelegt haben, nicht zum Abrufen von Plugins verwendet werden, sobald seine Quelle nicht mehr übereinstimmt. Blockierte Benutzer sehen einen Fehler, der die verwaltete Richtlinie benennt.

Wenn Sie diesen Schlüssel in der [claude.ai Admin-Konsole](https://code.claude.com/docs/de/server-managed-settings.md) festlegen, wendet claude.ai ihn auch an, wenn jemand in Ihrer Organisation einen Marketplace aus einem Git-Repository auf claude.ai hinzufügt, wie [Wie Einschränkungen funktionieren](https://code.claude.com/docs/de/plugins/org.md#restrict-what-users-can-install) beschreibt.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Array von Marketplace-Quellobjekten; siehe [Zulässige Quellentypen](#allowed-source-types)
* **Standard**: nicht gesetzt, daher können Benutzer jeden Marketplace hinzufügen. Ein leeres Array ist eine vollständige Sperrung, die jede Marketplace-Quelle blockiert, einschließlich des offiziellen Anthropic-Marketplace

Dieses Beispiel erlaubt zwei GitHub-Repositories, eines auf den `v2.0` Ref gepinnt und eines gehostete `marketplace.json` URL:

```json managed-settings.json theme={null}
{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme-corp/approved-plugins" },
    { "source": "github", "repo": "acme-corp/security-tools", "ref": "v2.0" },
    { "source": "url", "url": "https://plugins.example.com/marketplace.json" }
  ]
}
```

Sie können diesen Schlüssel auch als `allowedMarketplaces` schreiben; [Marketplace-Schlüssel-Aliase](#marketplace-key-aliases) beschreibt, wie Claude Code den Alias behandelt und welche Version ihn akzeptiert. Dieser Schlüssel ist ein Richtlinien-Gate: er kontrolliert, was Benutzer hinzufügen dürfen, registriert aber nichts. Um in einer Datei einzuschränken und vorab zu registrieren, siehe [Mit `extraKnownMarketplaces` kombinieren](#combine-with-extraknownmarketplaces). Für die benutzergerichtete Ansicht siehe [Verwaltete Marketplace-Einschränkungen](https://code.claude.com/docs/de/plugins/org.md#restrict-what-users-can-install).

#### Zulässige Quellentypen

Jeder Eintrag unten zeigt einen Zulassungslisten-Eintrag pro Quellentyp und die Felder, die er akzeptiert. Die meisten Typen stimmen genau überein; `hostPattern` und `pathPattern` stimmen per Regex überein, und `github` Einträge können eine [Owner-Wildcard](#owner-wildcards) verwenden.

| Quelle | Beispiel-Eintrag | Felder |
| :- | :- | :- |
| `github` | `{ "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" }` | `repo` erforderlich; `ref` ist ein Branch oder Tag; `path` ist ein Unterverzeichnis |
| `git` | `{ "source": "git", "url": "https://gitlab.example.com/tools/plugins.git", "ref": "production" }` | `url` erforderlich; `ref` und `path` wie für `github` |
| `url` | `{ "source": "url", "url": "https://plugins.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } }` | `url` erforderlich; `headers` fügt HTTP-Header für authentifizierten Zugriff hinzu |
| `file` | `{ "source": "file", "path": "/opt/acme-corp/plugins/marketplace.json" }` | `path` erforderlich, der absolute Pfad zu einer `marketplace.json` Datei |
| `directory` | `{ "source": "directory", "path": "/opt/acme-corp/approved-marketplaces" }` | `path` erforderlich, der absolute Pfad zu einem Verzeichnis mit `.claude-plugin/marketplace.json` |
| `hostPattern` | `{ "source": "hostPattern", "hostPattern": "^github\\.example\\.com$" }` | `hostPattern` erforderlich, ein Regex, das gegen den Marketplace-Host abgeglichen wird; verankern Sie es mit `^` und `$`, um den ganzen Host abzugleichen |
| `pathPattern` | `{ "source": "pathPattern", "pathPattern": "^/opt/approved/" }` | `pathPattern` erforderlich, ein Regex, das gegen den `path` von `file` und `directory` Quellen abgeglichen wird; beginnen Sie es mit `^`, um ein Präfix zu fixieren |
| `skills-dir` | `{ "source": "skills-dir" }` | Keine Felder |

Einige Quellentypen tragen Regeln über die Tabelle hinaus:

* **`url`**: Ein URL-Marketplace lädt nur die `marketplace.json` Datei herunter, und Claude Code lädt Plugin-Dateien nicht per relativem Pfad von diesem Server herunter, daher müssen seine Plugins eine [Plugin-Quelle](https://code.claude.com/docs/de/plugins/marketplace-reference.md#plugin-sources) verwenden, die nicht ein relativer Pfad ist, wie eine Archiv-URL, die auf demselben Host sein kann. Für Plugins mit relativen Pfaden verwenden Sie stattdessen einen Git-basierten Marketplace. Siehe [Plugins mit relativen Pfaden schlagen in URL-basierten Marketplaces fehl](https://code.claude.com/docs/de/plugins/troubleshooting.md#plugins-with-relative-paths-fail-in-url-based-marketplaces).
* **`hostPattern`**: Verwenden Sie es, um jeden Marketplace auf einem internen GitHub Enterprise oder GitLab Server zuzulassen, ohne jedes Repository aufzulisten. Claude Code gleicht `github` Quellen gegen `github.com` ab, nimmt den Hostnamen von `url` Quellen und nimmt ihn von `git` Quellen je nach [git URL](https://git-scm.com/docs/git-clone#_git_urls) Form:

  * Eine URL mit einem Schema, wie `https://` oder `ssh://`: der Hostname in der URL.
  * Eine SSH-Adresse ohne Schema, in Gits `user@host:path` Form, wie `git@git.example.com:tools/plugins.git`: der Host zwischen `@` und `:`, der der Host ist, mit dem Git sich verbindet.
  * Jede andere Form ohne Schema: kein Host, daher stimmt kein `strictKnownMarketplaces` `hostPattern` Eintrag damit überein. Für einen `blockedMarketplaces` `hostPattern` nimmt Claude Code einen Host aus einem breiteren Satz von Formen, daher kann ein Blocklist-Eintrag immer noch mit solch einer Form übereinstimmen. Vor v2.1.234 stimmte ein `strictKnownMarketplaces` `hostPattern` auch mit einigen Formen überein, die Git nicht als SSH-Adressen behandelt.

  `file` und `directory` Quellen haben keinen Host und stimmen niemals mit einem `hostPattern` Eintrag überein.
* **`pathPattern`**: Verwenden Sie es, um Dateisystem-Marketplaces neben `hostPattern` Einträgen für Netzwerkquellen zuzulassen. `".*"` erlaubt jeden lokalen Pfad; ein engeres Muster wie `"^/opt/approved/"` beschränkt auf ein Verzeichnis.
* **`skills-dir`**: Jede Zulassungsliste, auch eine leere, hindert Claude Code daran, [`@skills-dir` Plugins](https://code.claude.com/docs/de/plugins/loading#plugins-shared-through-a-repository) sowohl aus `~/.claude/skills/` als auch aus dem `.claude/skills/` eines Projekts zu laden. Um sie weiterhin zu laden, fügen Sie den `{ "source": "skills-dir" }` Eintrag hinzu und lassen [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) nicht gesetzt. Der Eintrag hat außerhalb dieses Schlüssels und `blockedMarketplaces` keine Bedeutung.

#### Owner-Wildcards

Ein `github` Eintrag, dessen `repo` Wert `"<owner>/*"` ist, stimmt mit jedem Repository unter diesem GitHub-Owner überein. Owner-Wildcards erfordern Claude Code v2.1.223 oder später und funktionieren nur in `strictKnownMarketplaces` und `blockedMarketplaces`. Überall sonst, wo eine `github` Quelle erscheint, wie `extraKnownMarketplaces` oder `/plugin marketplace add`, muss der `repo` Wert ein einzelnes Repository benennen. Vor v2.1.223 verglich Claude Code den Eintrag buchstäblich, daher stimmte ein Zulassungslisten-Eintrag mit keinem Repository überein und ein Blocklist-Eintrag blockierte nichts; Einträge für einzelne Repositories werden auf jeder Version erzwungen.

Dieser Eintrag erlaubt jeden Marketplace-Repository in der `acme-corp` Organisation:

```json managed-settings.json theme={null}
{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme-corp/*" }
  ]
}
```

Nur die ganze Repository-Namen-Position kann ein Wildcard sein. Claude Code ignoriert Einträge wie `*`, `*/plugins` oder `acme-corp/tools-*` als ungültig, daher stimmen sie mit keinem Repository überein.

Die Abgleichregeln unterscheiden sich zwischen den beiden Einstellungen:

| Regel | `strictKnownMarketplaces` | `blockedMarketplaces` |
| - | - | - |
| Abgleich von Quellschreibweisen | `owner/repo` Form nur. Eine Git-URL, die dasselbe Repository klont, stimmt nicht überein | Jede Schreibweise, einschließlich Git-URLs, die zum selben github.com Repository auflösen |
| Groß-/Kleinschreibung des Owners | Groß-/Kleinschreibung wird beachtet | Groß-/Kleinschreibung wird ignoriert |
| `ref` | Folgt den exakten Eintrag-Regeln: ein Eintrag mit einem `ref` stimmt nur mit Quellen mit diesem exakten Ref überein, und ein Eintrag ohne einen stimmt nur mit Quellen überein, die keinen Ref angeben | Ein Eintrag ohne einen `ref` blockiert alle Refs der Repositories, die er abgleicht |
| `path` | Lockerer als die exakten Eintrag-Regeln: ein Eintrag mit einem `path` erfordert diesen exakten Wert, während ein Eintrag ohne einen jeden Pfad im Repository abgleicht | Ein Eintrag ohne einen `path` blockiert alle Pfade der Repositories, die er abgleicht |

#### Exakter Abgleich

Für jeden Quellentyp außer Owner-Wildcard `github` Einträgen und den Regex-abgeglichenen `hostPattern` und `pathPattern` Einträgen erlaubt Claude Code eine Benutzer-Addition nur, wenn die Marketplace-Quelle genau mit einem Eintrag übereinstimmt. Für die Git-basierten Quellen `github` und `git` umfasst der exakte Abgleich die optionalen Felder:

* Der `repo` oder `url` muss genau übereinstimmen
* Das `ref` Feld muss genau übereinstimmen, oder beide müssen nicht definiert sein
* Das `path` Feld muss genau übereinstimmen, oder beide müssen nicht definiert sein

Zum Beispiel behandelt Claude Code jedes Paar unten als zwei verschiedene Quellen:

* `{ "source": "github", "repo": "acme-corp/plugins" }` und `{ "source": "github", "repo": "acme-corp/plugins", "ref": "main" }`
* `{ "source": "github", "repo": "acme-corp/plugins", "path": "marketplace" }` und `{ "source": "github", "repo": "acme-corp/plugins" }`

#### Nur den offiziellen Marketplace zulassen

Um den offiziellen Anthropic-Marketplace und nichts anderes zuzulassen, listen Sie sein Repository auf:

```json managed-settings.json theme={null}
{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "anthropics/claude-plugins-official" }
  ]
}
```

Mit diesem Eintrag behält Claude Code einen bereits registrierten offiziellen Marketplace bei und registriert den Marketplace auf einem neuen Computer automatisch, wenn Sie zum ersten Mal eine interaktive Terminalsitzung starten. Die automatische Registrierung verpasst am häufigsten:

* Nicht-interaktive Umgebungen, die vor der ersten interaktiven Terminalsitzung des Computers ausgeführt werden.
* Computer, auf denen Claude Code nur über die VS Code-Erweiterung ausgeführt wurde.
* Computer, auf denen Claude Code bereits eine interaktive Terminalsitzung unter einer Richtlinie ausgeführt hat, die den Marketplace blockierte, wie die leere Array-Sperrung. Claude Code zeichnet den blockierten Versuch auf und versucht es nicht erneut, nachdem sich die Richtlinie ändert.

Fügen Sie auf diesen Computern den Marketplace zu [`extraKnownMarketplaces`](#extraknownmarketplaces) in derselben `managed-settings.json` hinzu, damit Claude Code ihn automatisch registriert, oder führen Sie `claude plugin marketplace add anthropics/claude-plugins-official` aus.

#### Mit `extraKnownMarketplaces` kombinieren

Die beiden Schlüssel erfüllen unterschiedliche Aufgaben. Diese Tabelle vergleicht sie:

| Aspekt | `strictKnownMarketplaces` | `extraKnownMarketplaces` |
| - | - | - |
| Zweck | Durchsetzung der Organisationsrichtlinie | Team-Komfort |
| Einstellungsdatei | Nur verwaltete Einstellungen | Jede Einstellungsdatei |
| Verhalten | Blockiert nicht zulässige Additionen | Registriert fehlende Marketplaces |
| Wann erzwungen | Vor Netzwerk- und Dateisystemoperationen | Sofort aus Benutzer- oder verwalteten Einstellungen; nach dem Workspace-Vertrauensdialog für die Dateien eines Repositories |
| Kann überschrieben werden | Nein, höchster Vorrang | Ja, durch Einstellungen mit höherem Vorrang |
| Quellenformat | Direktes Quellobjekt | Benannter Marketplace mit einem verschachtelten `source` Objekt |

Um einen Marketplace sowohl einzuschränken als auch vorab zu registrieren für alle Benutzer, setzen Sie beide in `managed-settings.json`:

```json managed-settings.json theme={null}
{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme-corp/plugins" }
  ],
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": { "source": "github", "repo": "acme-corp/plugins" }
    }
  }
}
```

Mit nur `strictKnownMarketplaces` gesetzt, können Benutzer einen zulässigen Marketplace immer noch selbst mit `/plugin marketplace add` hinzufügen. Der offizielle Anthropic-Marketplace ist der einzige, den Claude Code automatisch registriert, und nur wenn die Zulassungsliste ihn zulässt. [Nur den offiziellen Marketplace zulassen](#allow-only-the-official-marketplace) listet die Computer auf, die er verpasst.

### `strictPluginOnlyCustomization`

Blockieren Sie Skills, Agents, Hooks und MCP-Server von Benutzer- und Projektquellen, daher können sie nur von Plugins oder verwalteten Einstellungen stammen. Kombinieren Sie es mit [`strictKnownMarketplaces`](#strictknownmarketplaces), um die vollständige Anpassungslieferkette zu kontrollieren: die Marketplace-Zulassungsliste kontrolliert, welche Plugins Benutzer installieren können.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: `true`, um alle vier Arten von Anpassung zu sperren, oder ein Array, das die zu sperrenden Arten benennt, von `"skills"`, `"agents"`, `"hooks"` und `"mcp"`
* **Standard**: nicht gesetzt, daher ist nichts gesperrt

Dieses Beispiel sperrt Skills und Hooks und lässt Agents und MCP-Server entsperrt:

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["skills", "hooks"]
}
```

Wenn Sie eine beliebige Oberfläche sperren, lädt Claude Code auch keine [Skills-Verzeichnis-Plugins](https://code.claude.com/docs/de/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings) mehr, also die Plugin-Ordner, die Benutzer unter `~/.claude/skills/` oder `.claude/skills/` ablegen. Benutzer legen diese Ordner selbst ab, anstatt sie aus einem Marketplace zu installieren, daher behandelt Claude Code sie unter dieser Einstellung als Benutzeranpassung.

Die vier Sub-Schlüssel-Einträge unten listen auf, was jede Oberfläche zusätzlich blockiert und was weiterhin geladen wird. Claude Code ignoriert Oberflächennamen, die es nicht erkennt, anstatt die Einstellungsdatei fehlschlagen zu lassen, daher können Sie neue Oberflächennamen hinzufügen, bevor jeder Client aktualisiert hat.

### `strictPluginOnlyCustomization.skills`

Sperren Sie die `skills` Oberfläche. Claude Code stoppt das Laden von Skills aus `~/.claude/skills/` und `.claude/skills/`, benutzerdefinierten Befehlen aus `~/.claude/commands/` und `.claude/commands/`, Skills und Befehlen unter `--add-dir` Verzeichnissen und Skills, die von Ihrem claude.ai-Konto synchronisiert werden. Es lädt weiterhin gebündelte Skills, Skills im verwalteten Richtlinienverzeichnis und Skills aus Plugins außer [Skills-Verzeichnis-Plugins](https://code.claude.com/docs/de/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings).

* **Bereich**: [`Managed`](#scopes)
* **Typ**: der String `"skills"` im [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) Array
* **Standard**: nicht gesperrt

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["skills"]
}
```

### `strictPluginOnlyCustomization.agents`

Sperren Sie die `agents` Oberfläche. Claude Code stoppt das Laden von Agents aus `~/.claude/agents/`, `.claude/agents/` und `--add-dir` Verzeichnissen. Es lädt weiterhin integrierte Agents, Agents im verwalteten Richtlinienverzeichnis und Agents aus Plugins außer [Skills-Verzeichnis-Plugins](https://code.claude.com/docs/de/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings).

* **Bereich**: [`Managed`](#scopes)
* **Typ**: der String `"agents"` im [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) Array
* **Standard**: nicht gesperrt

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["agents"]
}
```

### `strictPluginOnlyCustomization.hooks`

Sperren Sie die `hooks` Oberfläche:

* **Werden nicht mehr ausgeführt**:
  * Hooks aus Benutzer-, Projekt- und lokalen `settings.json`
  * Frontmatter-Hooks in Skills, benutzerdefinierten Befehlen und Agenten aus den Quellen, die eine [`skills`](#strictpluginonlycustomization-skills)- oder [`agents`](#strictpluginonlycustomization-agents)-Sperre blockieren würde
* **Werden weiterhin ausgeführt**: Hooks in verwalteten Einstellungen und Hooks aus Plugins außer [Skills-Verzeichnis-Plugins](https://code.claude.com/docs/de/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings)

Skills, benutzerdefinierte Befehle und Agenten, deren Frontmatter-Hooks nicht mehr ausgeführt werden, werden weiterhin geladen, solange ihre eigene Oberfläche nicht gesperrt ist.

Ein persönlicher oder Projekt-[Skill](https://code.claude.com/docs/de/skills.md#where-skills-live), der in seinem Frontmatter `hooks` deklariert, verliert außerdem seine [`allowed-tools`](https://code.claude.com/docs/de/skills#pre-approve-tools-for-a-skill)-Vorabgenehmigung, sodass Ihre Benutzer Berechtigungsabfragen für die Tools erhalten, die dieses Feld auflistet. Wenn ein solcher Skill über [`context: fork`](https://code.claude.com/docs/de/skills#run-skills-in-a-subagent) in einem Subagenten ausgeführt wird, behält er die Vorabgenehmigung. Ein Skill, der keine `hooks` deklariert, behält seine Vorabgenehmigung ebenfalls.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: der String `"hooks"` im [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) Array
* **Standard**: nicht gesperrt

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["hooks"]
}
```

### `strictPluginOnlyCustomization.mcp`

Sperren Sie die `mcp` Oberfläche. Claude Code stoppt das Laden von MCP-Servern aus `~/.claude.json` und `.mcp.json`. Es lädt weiterhin [`managed-mcp.json`](https://code.claude.com/docs/de/managed-mcp) Server, Server von [`managedMcpServers`](#managedmcpservers) und MCP-Server aus Plugins außer [Skills-Verzeichnis-Plugins](https://code.claude.com/docs/de/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings).

* **Bereich**: [`Managed`](#scopes)
* **Typ**: der String `"mcp"` im [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) Array
* **Standard**: nicht gesperrt

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["mcp"]
}
```

### `enabledPlugins`

Schalten Sie einzelne [Plugins](https://code.claude.com/docs/de/plugins/overview.md) ein oder aus, gekennzeichnet durch `plugin-name@marketplace-name`. Ein Plugin ohne Eintrag in einem beliebigen Bereich fällt auf seinen [`defaultEnabled`](https://code.claude.com/docs/de/plugins/manifest-reference#fields) Wert zurück. Wenn Sie ein Plugin mit `/plugin` oder `claude plugin enable` aktivieren oder deaktivieren, schreibt Claude Code diesen Schlüssel für Sie.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Objekt, das `plugin-name@marketplace-name` auf einen Boolean abbildet
* **Standard**: nicht gesetzt, daher folgt jedes Plugin seinem `defaultEnabled` Wert

Dieses Beispiel aktiviert zwei Plugins aus dem `team-tools` Marketplace und deaktiviert eines aus `personal`:

```json settings.json theme={null}
{
  "enabledPlugins": {
    "code-formatter@team-tools": true,
    "deployment-tools@team-tools": true,
    "experimental-features@personal": false
  }
}
```

Jeder Bereich dient einem anderen Zweck:

* **Benutzereinstellungen**: Ihre persönlichen Plugin-Voreinstellungen
* **Projekteinstellungen**: Plugins, die mit jedem im Repository geteilt werden
* **Lokale Einstellungen**: Überschreibungen pro Computer, gitignoriert, wenn Claude Code eine Einstellung dort speichert
* **Verwaltete Einstellungen**: Organisationsrichtlinie. Ein Plugin, das hier auf `false` gesetzt ist, ist von der Installation in jedem Bereich blockiert und im Marketplace verborgen

Projekteinstellungen haben Vorrang vor Benutzereinstellungen, daher deaktiviert das Setzen eines Plugins auf `false` in `~/.claude/settings.json` kein Plugin, das die `.claude/settings.json` des Projekts aktiviert. Um sich von einem von Projekt aktivierten Plugin auf Ihrem Computer abzumelden, setzen Sie es stattdessen auf `false` in `.claude/settings.local.json`. Plugins, die von verwalteten Einstellungen erzwungen aktiviert werden, können auf diese Weise nicht deaktiviert werden, da verwaltete Einstellungen lokale Einstellungen überschreiben.

Das Aktivieren eines Plugins aus einer externen Quelle wie einem GitHub-Repository oder npm-Paket in der `.claude/settings.json` eines Projekts installiert es nicht für andere Personen. Auf jedem Pfad, der Plugins lädt, meldet Claude Code das Plugin als nicht installiert, bis jeder Benutzer es selbst [installiert](https://code.claude.com/docs/de/plugins/org.md#require-plugins-per-repository).

### `extraKnownMarketplaces`

Registrieren Sie zusätzliche Plugin-Marketplaces nach Name, damit Personen, die das Repository öffnen, oder jeder, den Ihre verwalteten Einstellungen erreichen, den Marketplace erhalten, ohne ihn selbst hinzuzufügen. Claude Code registriert jeden Marketplace, den es noch nicht kennt. Ob ein Plugin, das [`enabledPlugins`](#enabledplugins) von ihm benennt, installiert wird, hängt von der Plugin-Quelle und welche Datei es aktiviert ab; dieser Eintrag hat die Regeln.

* **Bereich**: [`Any file`](#scopes). Claude Code berücksichtigt Einträge in der `.claude/settings.json` oder `.claude/settings.local.json` eines Repositories nur, nachdem Sie den Workspace-Vertrauensdialog für diesen Ordner akzeptieren; in einem Ordner, dem Sie nicht vertrauen, einschließlich eines `-p` Laufs dort, ignoriert es sie ohne Nachricht.
* **Typ**: Objekt, das einen Marketplace-Namen auf ein Objekt mit einem `source` Objekt und einem optionalen `autoUpdate` Boolean abbildet
* **Standard**: nicht gesetzt

Dieses Beispiel registriert einen GitHub-Marketplace und einen Marketplace von einer selbst gehosteten Git-URL:

```json settings.json theme={null}
{
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": {
        "source": "github",
        "repo": "acme-corp/claude-plugins"
      }
    },
    "security-plugins": {
      "source": {
        "source": "git",
        "url": "https://git.example.com/security/plugins.git"
      }
    }
  }
}
```

[Was lädt, bevor Sie einen Ordner vertrauen](https://code.claude.com/docs/de/permissions.md#what-runs-before-you-trust-a-folder) vergleicht das Vertrauens-Gate mit dem anderen Inhalt, den ein Repository liefern kann. Sie können diesen Schlüssel auch als `additionalMarketplaces` schreiben; siehe [Marketplace-Schlüssel-Aliase](#marketplace-key-aliases).

Setzen Sie `"autoUpdate": true` neben `source`, um Claude Code zu veranlassen, diesen Marketplace zu aktualisieren und seine installierten Plugins nach dem Start im Hintergrund zu aktualisieren. Wenn weggelassen, standardmäßig `claude-plugins-official` und die meisten anderen offiziellen Anthropic-Marketplaces auf `true`, und Drittanbieter-Marketplaces standardmäßig auf `false`. Siehe [Konfigurieren Sie Auto-Updates](https://code.claude.com/docs/de/plugins/install.md#keep-plugins-updated).

Wenn mehr als eine Einstellungsdatei einen Marketplace-Eintrag unter demselben Namen definiert, verwendet Claude Code den Eintrag aus der [höchsten Prioritätsdatei](https://code.claude.com/docs/de/settings.md#settings-precedence) ganz. Dieser Eintrag ersetzt den Eintrag mit niedrigerer Priorität und erbt keine seiner Felder, daher kann eine Neudefinition nicht die `source.headers` Anmeldedaten einer Datei mit einer URL kombinieren, die eine andere Datei kontrolliert. Vor v2.1.228 fusionierte Claude Code Einträge mit demselben Namen Feld für Feld, daher konnte ein Eintrag in einer höher priorisierten Datei Felder erben, die er nicht setzte, einschließlich `headers` einer anderen Datei.

#### Marketplace-Quellentypen

Das `source` Objekt nimmt eine dieser Formen an:

* **`github`**: ein GitHub-Repository, mit `repo`
* **`git`**: jede Git-URL, mit `url`
* **`url`**: eine direkte URL zu einer `marketplace.json` Datei, mit `url` und optionalen `headers` und `headersHelper` für authentifizierten Zugriff. `headersHelper` benennt einen Befehl, der Header druckt, deren Werte zu kurzlebig sind, um in `headers` aufzulisten, und erfordert Claude Code v2.1.238 oder später
* **`file`**: ein lokaler Pfad zu einer `marketplace.json` Datei, mit `path`
* **`directory`**: ein lokaler Dateisystem-Pfad, mit `path`. Verwenden Sie ihn für die Entwicklung oder für einen Marketplace, den Ihre Organisation [auf jedem Computer bereitstellt](https://code.claude.com/docs/de/plugins/mods/admin.md#install-your-organizations-mods).
* **`settings`**: ein Inline-Marketplace, der direkt in der Einstellungsdatei ohne ein gehostetes Repository deklariert ist, mit `name` und `plugins`

Der `git` Quellentyp funktioniert mit jedem Git-Hosting-Service, einschließlich selbst gehosteter GitLab und Bitbucket. Claude Code klont das Repository mit derselben Authentifizierung, die `git clone` auf diesem Computer verwenden würde: konfigurierte Credential-Helper oder SSH-Schlüssel. Ein Provider-Token wie `GITHUB_TOKEN` wird durch einen Credential-Helper wirksam, der ihn liest. Siehe [Private Repositories](https://code.claude.com/docs/de/plugins/host-marketplace.md#grant-access-to-a-private-marketplace) für Setup-Details.

Für `github` und `git` Quellen lädt Claude Code niemals [Git LFS](https://git-lfs.com) Inhalte herunter, wenn es das Marketplace-Repository klont, um es hinzuzufügen oder zu aktualisieren. LFS-verfolgte Dateien werden als Zeiger-Dateien ausgecheckt, und die Ausgabe zum Hinzufügen oder Aktualisieren meldet, wie viele.

Das `skipLfs` Feld im `source` Objekt wird akzeptiert und hat keine Auswirkung. Vor v2.1.274 lud Claude Code LFS-Inhalte herunter, es sei denn, Sie setzen `"skipLfs": true`.

Für eine `url` Quelle setzen Sie `headersHelper` im `source` Objekt, wenn die Anmeldedaten in `headers` ablaufen und ein Befehl eine frische produzieren muss. Erfordert Claude Code v2.1.238 oder später. Für das, was der Befehl drucken muss und wo Claude Code ihn ausführt, siehe [Schreiben Sie den headersHelper-Befehl](https://code.claude.com/docs/de/plugins/host-marketplace.md#write-the-headershelper-command), und für die Fälle, in denen Claude Code ihn nicht ausführt, siehe [Wenn Claude Code einen headersHelper-Befehl überspringt oder seine Ausgabe verwirft](https://code.claude.com/docs/de/plugins/host-marketplace.md#when-claude-code-skips-a-headershelper-command-or-drops-its-output). Sobald Sie `headersHelper` auf einer `https://` Marketplace-URL setzen, führt Claude Code den Befehl an zwei Punkten aus und verwendet die Ausgabe eines Laufs für bis zu 60 Sekunden erneut:

* Vor jedem Abrufen von diesem Marketplace `marketplace.json`, einschließlich einer späteren Aktualisierung. Claude Code sendet die gedruckten Header mit diesem Abrufen.
* Vor jedem Plugin-Archiv-Download auf dem Ursprung der Marketplace-URL, was dasselbe Schema, Host und Port bedeutet. Claude Code sendet die Ausgabe mit diesem Download, und kein anderer Download erhält die Header.

Claude Code ignoriert jeden `headersHelper`, der in der `.claude/settings.json` oder `.claude/settings.local.json` eines Verzeichnisses gesetzt ist, das Sie mit [`--add-dir`](https://code.claude.com/docs/de/permissions#what-runs-before-you-trust-a-folder) hinzufügen, auf einer `url` Quelle und auf einem Inline-Plugin-Eintrag gleichermaßen, und sendet nur die festen `headers`, die in dieser Datei gesetzt sind. [Wie Benutzer einen headersHelper-Befehl akzeptieren](https://code.claude.com/docs/de/plugins/host-marketplace.md#how-users-accept-a-headershelper-command) behandelt die anderen Einstellungsdateien.

Plugins, die in einer `settings` Quelle aufgelistet sind, müssen externe Quellen wie GitHub oder npm referenzieren, und der `name` muss dem Marketplace-Schlüssel entsprechen. Sie aktivieren immer noch jedes Plugin separat in `enabledPlugins`. Dieses Beispiel deklariert ein Plugin inline:

```json settings.json theme={null}
{
  "extraKnownMarketplaces": {
    "team-tools": {
      "source": {
        "source": "settings",
        "name": "team-tools",
        "plugins": [
          {
            "name": "code-formatter",
            "source": {
              "source": "github",
              "repo": "acme-corp/code-formatter"
            }
          }
        ]
      }
    }
  }
}
```

Ein Plugin-Eintrag unter `source: 'settings'`, dessen eigene `source` ein [`archive`](https://code.claude.com/docs/de/plugins/marketplace-reference#archive-plugin-source) ist, kann `headers` für den Archiv-Download setzen. Wenn der Wert, den Sie in `headers` setzen würden, kurzlebig ist, wie ein Token, den Ihre Registry auf Anfrage prägt, setzen Sie stattdessen einen `headersHelper` Befehl. Ein Eintrag kann beide setzen. Beide Felder erfordern Claude Code v2.1.238 oder später.

Claude Code sendet die `headers` des Eintrags und alles, was der Befehl druckt, mit dem Archiv-Download dieses Plugins und mit keinem anderen Download. Claude Code führt den Befehl nur aus, wenn ein Benutzer [dieses eine Plugin selbst installiert oder aktualisiert](https://code.claude.com/docs/de/plugins/host-marketplace.md#how-users-accept-a-headershelper-command). Drei weitere Regeln hängen davon ab, welche Datei den Eintrag hält:

* **`strict`**: anders als ein Eintrag in einem Marketplace `marketplace.json` benötigt ein Eintrag in Einstellungen kein `"strict": false`, weil eine Einstellungsdatei keine Manifest-Felder zum Inline-Einfügen trägt. Siehe [Strict Mode](https://code.claude.com/docs/de/plugins/marketplace-reference.md#strict-mode).
* **Ordner-Vertrauen**: für einen Eintrag in der `.claude/settings.json` oder `.claude/settings.local.json` eines Projekts führt Claude Code den Befehl nur aus, nachdem der Benutzer auch [diesen Ordner vertraut hat](https://code.claude.com/docs/de/permissions.md#what-runs-before-you-trust-a-folder).
* **Header-Filter**: Claude Code verwirft [Request-Routing- und Client-Identitäts-Header-Namen](https://code.claude.com/docs/de/plugins/host-marketplace.md#when-claude-code-skips-a-headershelper-command-or-drops-its-output) aus einem Eintrag in der `.claude/settings.json` oder `.claude/settings.local.json` eines Projekts, weil ein Repository diese Dateien liefern kann. Claude Code wendet denselben Filter auf einen Katalog-Eintrag und auf einen Eintrag in einem `--add-dir` Verzeichnis-Einstellungen an, und keinen Filter auf einen Eintrag in Ihren Benutzereinstellungen, einer `--settings` Datei oder verwalteten Einstellungen.

#### Marketplace-Schlüssel-Aliase

Auf Claude Code v2.1.232 oder später können Sie `extraKnownMarketplaces` als `additionalMarketplaces` und `strictKnownMarketplaces` als `allowedMarketplaces` schreiben. Claude Code behandelt jeden Alias wie folgt:

* Frühere Versionen ignorieren den Alias, daher behalten Sie die kanonische Schreibweise in einer Datei, die auch ältere Versionen lesen, wie eine verwaltete Einstellungsdatei für eine Flotte mit gemischten Claude Code Versionen.
* In jeder Einstellungsdatei, die den kanonischen Schlüssel akzeptiert, liest Claude Code den Alias genau wie den kanonischen Schlüssel.
* Claude Code kann `additionalMarketplaces` zu `extraKnownMarketplaces` umschreiben, wenn es die Datei aktualisiert.
* Wenn Sie beide Schreibweisen in einer Datei setzen, verwendet Claude Code den kanonischen Wert und ignoriert den Alias.

### `pluginConfigs`

Speichern Sie die nicht-sensiblen Antworten, die Sie einem Plugin [`userConfig`](https://code.claude.com/docs/de/plugins/manifest-reference#user-configuration) Konfigurationsdialog geben, gekennzeichnet durch Plugin-ID. Claude Code schreibt diesen Schlüssel in Ihre Benutzereinstellungen, wenn Sie den Dialog ausfüllen, daher müssen Sie ihn nicht von Hand bearbeiten. Claude Code speichert sensible Optionen stattdessen im macOS Keychain, fällt auf `~/.claude/.credentials.json` zurück, wenn der Keychain den Schreibvorgang ablehnt; auf Plattformen ohne einen unterstützten Keychain speichert es sie in `~/.claude/.credentials.json`.

* **Bereich**: [`User or managed`](#scopes)
* **Typ**: Objekt, das eine Plugin-ID auf ein Objekt mit einem `options` Feld abbildet, das jeden Optionsnamen auf einen String, eine Zahl, einen Boolean oder ein Array von Strings abbildet, und ein optionales `mcpServers` Feld mit Pro-Server-Benutzer-Konfigurationswerten in derselben Form
* **Standard**: nicht gesetzt

Dieses Beispiel speichert die `api_endpoint` Option für das `deployer` Plugin aus `acme-tools`:

```json settings.json theme={null}
{
  "pluginConfigs": {
    "deployer@acme-tools": {
      "options": {
        "api_endpoint": "https://api.example.com"
      }
    }
  }
}
```

Integrierte Plugins speichern ihre Optionen unter demselben Schlüssel mit einem `@builtin` Suffix. Zum Beispiel ist die [**Projektanweisungen**](https://code.claude.com/docs/de/memory.md#choose-which-instruction-files-load) Einstellung, die kontrolliert, ob Claude Code `AGENTS.md` Dateien liest, `pluginConfigs["cc-plugin-agents-md@builtin"].options.instructionFiles`. Vor v2.1.285 lautete die ID des Plugins `agents-md@builtin`. Spätere Versionen lesen einen Eintrag unter beiden IDs.

Claude Code ignoriert Projekt- und lokale Einträge, weil es diese Werte in Plugin-Hook-, MCP- und LSP-Konfigurationen einsetzt und ein geklontes Repository sie nicht liefern können darf.

### `prependPlugins`

Listen Sie die verwalteten Plugins auf, deren [Mods](https://code.claude.com/docs/de/plugins/mods/overview.md) vor jedem Mod ausgeführt werden, den ein Benutzer installiert, in der aufgeführten Reihenfolge. Wenn Sie diesen Schlüssel in verwalteten Einstellungen setzen, nennen Sie `sec-default@builtin` in der Liste, um den integrierten Schutz beizubehalten. In verwalteten Einstellungen überspringt Claude Code eine ID, deren Plugin nicht als Plugin Ihrer Organisation gilt. Siehe [Mods Ihrer Organisation installieren und die Reihenfolge festlegen](https://code.claude.com/docs/de/plugins/mods/admin.md#install-your-organizations-mods) für diese Bedingungen und dafür, wie die beiden Reihenfolge-Schlüssel zusammenwirken.

* **Geltungsbereich**: [`User or managed`](#scopes). Claude Code liest den Schlüssel aus verwalteten Einstellungen. Aus Benutzereinstellungen liest es den Schlüssel nur auf einem Computer ohne verwaltete Einstellungen und in einer Sitzung, deren Anmeldedaten nicht aus einem Team- oder Enterprise-`/login` stammen. In Projekt- und lokalen Einstellungen sowie in einer `--settings` Datei ignoriert es den Schlüssel.
* **Typ**: Array von `plugin-name@marketplace-name` Strings
* **Standard**: nicht gesetzt

```json managed-settings.json theme={null}
{
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": { "source": "directory", "path": "/opt/acme/claude-plugins" }
    }
  },
  "enabledPlugins": { "acme-guard@acme-tools": true },
  "prependPlugins": ["acme-guard@acme-tools", "sec-default@builtin"]
}
```

### `appendPlugins`

Listen Sie die verwalteten Plugins auf, deren [Mods](https://code.claude.com/docs/de/plugins/mods/overview.md) nach jedem Mod ausgeführt werden, den ein Benutzer installiert, in der aufgeführten Reihenfolge. Eine ID, die sowohl in `prependPlugins` als auch in `appendPlugins` aufgeführt ist, wird vorangestellt. In verwalteten Einstellungen überspringt Claude Code eine ID, deren Plugin nicht [als Plugin Ihrer Organisation gilt](https://code.claude.com/docs/de/plugins/mods/admin.md#install-your-organizations-mods).

* **Geltungsbereich**: [`User or managed`](#scopes). Claude Code liest den Schlüssel aus verwalteten Einstellungen. Aus Benutzereinstellungen liest es den Schlüssel nur auf einem Computer ohne verwaltete Einstellungen und in einer Sitzung, deren Anmeldedaten nicht aus einem Team- oder Enterprise-`/login` stammen. In Projekt- und lokalen Einstellungen sowie in einer `--settings` Datei ignoriert es den Schlüssel.
* **Typ**: Array von `plugin-name@marketplace-name` Strings
* **Standard**: nicht gesetzt

```json managed-settings.json theme={null}
{
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": { "source": "directory", "path": "/opt/acme/claude-plugins" }
    }
  },
  "enabledPlugins": { "acme-audit@acme-tools": true },
  "appendPlugins": ["acme-audit@acme-tools"]
}
```

## MCP

Steuern Sie, mit welchen MCP-Servern Claude Code sich verbindet, und welche eine Organisation zulässt. Siehe [Mit externen Tools über MCP verbinden](https://code.claude.com/docs/de/mcp.md) und [Verwaltete MCP-Konfiguration](https://code.claude.com/docs/de/managed-mcp.md).

### `allowAllClaudeAiMcps`

Laden Sie die [claude.ai-Konnektoren](https://code.claude.com/docs/de/mcp.md#use-mcp-servers-from-claude-ai), die Claude Code selbst abruft, zusammen mit einer bereitgestellten `managed-mcp.json`. Ohne diesen Schlüssel übernimmt `managed-mcp.json` die ausschließliche Kontrolle über MCP-Server und unterdrückt diese Konnektoren.

* **Geltungsbereich**: [`Managed`](#scopes). Benutzer können Konnektoren, die durch die ausschließliche Kontrolle unterdrückt wurden, nicht erneut aktivieren.
* **Typ**: Boolean
  * `true`: Claude Code lädt die claude.ai-Konnektoren zusammen mit einer bereitgestellten `managed-mcp.json`
  * `false`: eine bereitgestellte `managed-mcp.json` übernimmt die ausschließliche Kontrolle über MCP-Server und unterdrückt die claude.ai-Konnektoren, [die Claude Code selbst abruft](https://code.claude.com/docs/de/mcp.md#how-connectors-reach-claude-code)
* **Standard**: `false`, daher unterdrückt eine bereitgestellte `managed-mcp.json` die claude.ai-Konnektoren, die Claude Code selbst abruft

```json managed-settings.json theme={null}
{
  "allowAllClaudeAiMcps": true
}
```

[`allowedMcpServers`](#allowedmcpservers) und [`deniedMcpServers`](#deniedmcpservers) gelten weiterhin für die Konnektoren, die dieser Schlüssel lädt. Konnektoren, die an eine [Cloud-Sitzung](https://code.claude.com/docs/de/claude-code-on-the-web.md) geliefert werden, deren Host eine `managed-mcp.json` trägt, wie z. B. einen selbstgehosteten Runner, bleiben unterdrückt. Siehe [claude.ai-Konnektoren neben dem verwalteten Satz zulassen](https://code.claude.com/docs/de/managed-mcp.md#allow-claude-ai-connectors-alongside-the-managed-set).

### `allowClaudeInChromeWithManagedMcp`

Lassen Sie den integrierten [Claude in Chrome](https://code.claude.com/docs/de/chrome.md)-Server zusammen mit einer bereitgestellten `managed-mcp.json` laufen. Ohne diesen Schlüssel blockiert eine bereitgestellte `managed-mcp.json` Claude in Chrome in Terminal-Sitzungen. Erfordert Claude Code v2.1.282 oder später.

* **Geltungsbereich**: [`Managed`](#scopes), nur aus den eigenen verwalteten Einstellungen des Geräts: einer per MDM bereitgestellten plist oder einem HKLM-Registrierungsschlüssel oder einer System-`managed-settings.json`-Datei. Claude Code ignoriert ihn in servergesteuerten Einstellungen, in der vom Benutzer beschreibbaren HKCU-Registrierung sowie in Benutzer- oder Projekteinstellungen.
* **Typ**: Boolean
  * `true`: der integrierte Claude in Chrome-Server kann zusammen mit einer bereitgestellten `managed-mcp.json` laufen
  * `false`: eine bereitgestellte `managed-mcp.json` blockiert Claude in Chrome in Terminal-Sitzungen
* **Standard**: `false`, daher blockiert eine bereitgestellte `managed-mcp.json` Claude in Chrome in Terminal-Sitzungen

```json managed-settings.json theme={null}
{
  "allowClaudeInChromeWithManagedMcp": true
}
```

Ein [`deniedMcpServers`](#deniedmcpservers)-Eintrag für `claude-in-chrome` blockiert den Server auch bei aktiviertem Schlüssel weiterhin. Siehe [Claude in Chrome neben dem verwalteten Satz zulassen](https://code.claude.com/docs/de/managed-mcp.md#allow-claude-in-chrome-alongside-the-managed-set).

### `allowedMcpServers`

Erstellen Sie eine Allowlist der MCP-Server, die Personen hinzufügen können. Claude Code blockiert jeden Server, der nicht mit einem Eintrag übereinstimmt, überall dort, wo er definiert ist, einschließlich Plugin-Server, Server, die ein Benutzer mit `--mcp-config` übergibt, und Server von claude.ai.

Integrierte Server wie Claude in Chrome, der `ide`-Server, mit dem Claude Code sich in einer laufenden [VS Code](https://code.claude.com/docs/de/vs-code.md#the-built-in-ide-mcp-server)- oder [JetBrains](https://code.claude.com/docs/de/jetbrains.md#the-built-in-ide-mcp-server)-IDE verbindet, und Server, die die CLI selbst konfiguriert, sind von der Allowlist ausgenommen, und die Denylist gilt weiterhin für sie. Ab Claude Code v2.1.268 sind auch die Slack-Tools einer [Claude Tag](https://code.claude.com/docs/de/claude-tag.md)-Sitzung von der Allowlist ausgenommen, und die Denylist gilt weiterhin für sie. In-Process-`type: "sdk"`-Server sind von beiden Listen ausgenommen; die [App, die die Sitzung gestartet hat](https://code.claude.com/docs/de/mcp.md#how-connectors-reach-claude-code), registriert sie.

Server, die Ihre Organisation bereitstellt, sind auch von der Allowlist ausgenommen, und die Denylist gilt weiterhin für sie. Die Ausnahme deckt jeden [`managedMcpServers`](#managedmcpservers)-Eintrag ab, und jeden [`managed-mcp.json`](https://code.claude.com/docs/de/managed-mcp#exclusive-control-with-managed-mcp-json)-Eintrag, dessen Werte [keine `${VAR}`-Erweiterung außerhalb von `env`](https://code.claude.com/docs/de/managed-mcp#how-allowlists-and-denylists-apply-to-the-managed-set) verwenden. Siehe [Wie ein Server bewertet wird](https://code.claude.com/docs/de/managed-mcp.md#how-a-server-is-evaluated) für die vollständige Prüfreihenfolge. Vor v2.1.259 mussten Server aus `managed-mcp.json` auch übereinstimmen.

* **Geltungsbereich**: [`Any file`](#scopes). Einträge aus jeder Datei werden in eine Allowlist zusammengeführt, es sei denn, [`allowManagedMcpServersOnly`](#allowmanagedmcpserversonly) ist gesetzt. Stellen Sie es in verwalteten Einstellungen bereit, um es durchzusetzen.
* **Typ**: Array von Objekten, jedes mit genau einem Schlüssel. Verwenden Sie `serverName`, einen String, der auf Buchstaben, Zahlen, Bindestriche und Unterstriche beschränkt ist; `serverCommand`, ein Array des Befehls und seiner Argumente, die genau übereinstimmen; oder `serverUrl`, ein URL-Muster mit `*`-Platzhaltern
* **Standard**: nicht gesetzt, daher ist jeder Server zulässig; ein leeres Array blockiert jeden Server, den Benutzer hinzufügen

Dieses Beispiel erlaubt nur den stdio-Server, den der aufgelistete `npx`-Befehl startet:

```json settings.json theme={null}
{
  "allowedMcpServers": [
    { "serverCommand": ["npx", "-y", "@modelcontextprotocol/server-filesystem"] }
  ]
}
```

Ein [`deniedMcpServers`](#deniedmcpservers)-Eintrag hat Vorrang, daher wird ein Server auf beiden Listen blockiert. Sobald die Liste einen `serverCommand`-Eintrag enthält, muss ein stdio-Server mit einem `serverCommand`-Eintrag übereinstimmen, und sobald sie einen `serverUrl`-Eintrag enthält, muss ein Remote-Server mit einem `serverUrl`-Eintrag übereinstimmen: eine `serverName`-Übereinstimmung lässt diese Art von Server nicht mehr zu. Siehe [Richtlinienbasierte Kontrolle mit Allowlists und Denylists](https://code.claude.com/docs/de/managed-mcp.md#policy-based-control-with-allowlists-and-denylists).

### `allowManagedMcpServersOnly`

Machen Sie die verwaltete Allowlist zur einzigen, die gilt. Claude Code liest dann [`allowedMcpServers`](#allowedmcpservers) nur aus verwalteten Einstellungen und ignoriert Allowlists in Benutzer-, Projekt- und lokalen Einstellungen; [`deniedMcpServers`](#deniedmcpservers) wird weiterhin aus jedem Geltungsbereich der Einstellungen zusammengeführt, daher können Benutzer weiterhin Server für sich selbst blockieren. Administratoren setzen es so, dass die eigenen Einstellungen eines Benutzers nicht erweitern können, was die verwaltete Allowlist zulässt.

* **Geltungsbereich**: [`Managed`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code liest `allowedMcpServers` nur aus verwalteten Einstellungen und ignoriert Allowlists in Benutzer-, Projekt- und lokalen Einstellungen
  * `false`: Allowlists aus jedem Geltungsbereich der Einstellungen werden zusammengeführt
* **Standard**: `false`, daher werden Allowlists aus jedem Geltungsbereich der Einstellungen zusammengeführt

Dieses Beispiel sperrt die Allowlist auf verwaltete Einstellungen und erlaubt nur den Server namens `github`:

```json managed-settings.json theme={null}
{
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [
    { "serverName": "github" }
  ]
}
```

Benutzer können weiterhin ihre eigenen MCP-Server hinzufügen; nur Server, die mit der verwalteten Allowlist übereinstimmen, werden geladen. Siehe [Allowlist auf verwaltete Einstellungen beschränken](https://code.claude.com/docs/de/managed-mcp.md#restrict-the-allowlist-to-managed-settings-only).

### `deniedMcpServers`

Blockieren Sie bestimmte MCP-Server. Claude Code weigert sich, einen übereinstimmenden Server zu laden, überall dort, wo er definiert ist, einschließlich Plugin-Server, Server, die mit `--mcp-config` übergeben werden, Server aus `managed-mcp.json`, Server aus [`managedMcpServers`](#managedmcpservers), und die claude.ai-Konnektoren, [die es selbst abruft](https://code.claude.com/docs/de/mcp.md#how-connectors-reach-claude-code). In-Process-`type: "sdk"`-Server sind ausgenommen; die App, die die Sitzung gestartet hat, registriert sie.

* **Geltungsbereich**: [`Any file`](#scopes). Einträge aus jeder Datei werden in eine Denylist zusammengeführt, und [`allowManagedMcpServersOnly`](#allowmanagedmcpserversonly) ändert das nicht. Stellen Sie es in verwalteten Einstellungen bereit, um es durchzusetzen.
* **Typ**: Array von Objekten, jedes mit genau einem Schlüssel: `serverName`, ein String, daher funktioniert der Anzeigename eines claude.ai-Konnektors wie `"claude.ai Slack"`; `serverCommand`, ein Array des Befehls und seiner Argumente, die genau übereinstimmen; oder `serverUrl`, ein URL-Muster mit `*`-Platzhaltern
* **Standard**: nicht gesetzt, daher wird kein Server blockiert; ein leeres Array blockiert auch nichts

```json settings.json theme={null}
{
  "deniedMcpServers": [
    { "serverName": "filesystem" }
  ]
}
```

Die Denylist hat Vorrang vor [`allowedMcpServers`](#allowedmcpservers), daher wird ein Server auf beiden Listen blockiert. Siehe [Richtlinienbasierte Kontrolle mit Allowlists und Denylists](https://code.claude.com/docs/de/managed-mcp.md#policy-based-control-with-allowlists-and-denylists).

### `disableClaudeAiConnectors`

Schalten Sie die [claude.ai-MCP-Konnektoren](https://code.claude.com/docs/de/mcp.md#use-mcp-servers-from-claude-ai) aus, [die Claude Code selbst abruft](https://code.claude.com/docs/de/mcp.md#how-connectors-reach-claude-code), sodass es sie weder abruft noch verbindet. Ein `true` in einer beliebigen Einstellungsdatei gilt: eine eingecheckte Projekt-`.claude/settings.json` kann ein Repository von diesen Konnektoren abmelden, aber ein Projekt-Level-`false` kann ein Benutzer- oder verwaltetes Level-`true` nicht überschreiben.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code ruft diese Konnektoren weder ab noch verbindet sie
  * `false`: dasselbe wie nicht gesetzt; Claude Code ruft Ihre Konnektoren ab, es sei denn, eine andere Einstellungsdatei oder `ENABLE_CLAUDEAI_MCP_SERVERS` schaltet sie aus
* **Standard**: `false`, daher ruft Claude Code Ihre Konnektoren ab
* **Pro-Sitzungs-Überschreibungen**: [`ENABLE_CLAUDEAI_MCP_SERVERS`](https://code.claude.com/docs/de/env-vars) auf `false` gesetzt schaltet Konnektoren für eine Sitzung aus; welcher der beiden sie auch ausschaltet, der andere kann sie nicht wieder einschalten

```json settings.json theme={null}
{
  "disableClaudeAiConnectors": true
}
```

Server, die Sie explizit mit `--mcp-config` übergeben, sind nicht betroffen. Um einzelne Konnektoren statt aller zu blockieren, verwenden Sie [`deniedMcpServers`](#deniedmcpservers). Siehe [claude.ai-Konnektoren deaktivieren](https://code.claude.com/docs/de/mcp.md#disable-claude-ai-connectors).

### `disabledMcpjsonServers`

Lehnen Sie bestimmte Server ab, die in der `.mcp.json`-Datei eines Projekts definiert sind, damit Claude Code sich nie mit ihnen verbindet oder Sie auffordert, sie zu genehmigen. Eine Ablehnung in einer beliebigen Einstellungsdatei gilt, einschließlich einer Projekt-`.claude/settings.json`, die in das Repository eingecheckt ist.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Array von Strings, die Servernamen, wie sie in `.mcp.json` erscheinen
* **Standard**: nicht gesetzt

```json settings.json theme={null}
{
  "disabledMcpjsonServers": ["filesystem"]
}
```

Claude Code schreibt diesen Schlüssel in `.claude/settings.local.json`, wenn Sie einen Server im Genehmigungsdialog ablehnen. `claude mcp get <name>` zeigt einen abgelehnten Server als `✘ Rejected (see disabledMcpjsonServers in settings)` an. Ablehnung hat Vorrang vor [`enabledMcpjsonServers`](#enabledmcpjsonservers) und [`enableAllProjectMcpServers`](#enableallprojectmcpservers).

### `enableAllProjectMcpServers`

Genehmigen Sie jeden MCP-Server, der in Projekt-`.mcp.json`-Dateien definiert ist, ohne Nachfrage. Claude Code schreibt diesen Schlüssel in `.claude/settings.local.json`, wenn Sie wählen, alle Server im Genehmigungsdialog zu genehmigen.

* **Geltungsbereich**: [`Any file`](#scopes). In einem Ordner, dessen Vertrauensdialog Sie nicht akzeptiert haben, berücksichtigt Claude Code ihn aus Benutzereinstellungen, verwalteten Einstellungen und `--settings` und ignoriert ihn in der gemeinsamen Projektdatei, sowohl in der Sitzung als auch für `claude mcp list` und `claude mcp get`; [Projektserver-Genehmigungen und Workspace-Vertrauen](https://code.claude.com/docs/de/mcp.md#project-server-approvals-and-workspace-trust) beschreibt, wann eine nicht nachverfolgte `.claude/settings.local.json` ebenfalls zählt.
* **Typ**: Boolean
  * `true`: Claude Code genehmigt jeden MCP-Server, der in Projekt-`.mcp.json`-Dateien definiert ist, ohne Nachfrage
  * `false`: Claude Code fordert Sie auf, jeden Server zu genehmigen. In einem vertrauenswürdigen Ordner überschreibt ein `false` in einer Datei mit höherem Vorrang ein `true` in einer niedrigeren; in einem Ordner, dem Sie nicht vertrauen, ist ein `true` in einer beliebigen berücksichtigten Datei ausreichend
* **Standard**: nicht gesetzt, daher fordert Claude Code Sie auf, jeden Server zu genehmigen

```json settings.json theme={null}
{
  "enableAllProjectMcpServers": true
}
```

Ein [`disabledMcpjsonServers`](#disabledmcpjsonservers)-Eintrag lehnt einen Server weiterhin ab.

### `enabledMcpjsonServers`

Genehmigen Sie bestimmte Server, die in Projekt-`.mcp.json`-Dateien definiert sind, damit Claude Code sich mit ihnen verbindet, ohne zu fragen. Claude Code schreibt diesen Schlüssel in `.claude/settings.local.json`, wenn Sie einen Server im Genehmigungsdialog genehmigen.

* **Geltungsbereich**: [`Any file`](#scopes). In einem Ordner, dessen Vertrauensdialog Sie nicht akzeptiert haben, berücksichtigt Claude Code ihn aus Benutzereinstellungen, verwalteten Einstellungen und `--settings` und ignoriert ihn in der gemeinsamen Projektdatei, sowohl in der Sitzung als auch für `claude mcp list` und `claude mcp get`; [Projektserver-Genehmigungen und Workspace-Vertrauen](https://code.claude.com/docs/de/mcp.md#project-server-approvals-and-workspace-trust) beschreibt, wann eine nicht nachverfolgte `.claude/settings.local.json` ebenfalls zählt.
* **Typ**: Array von Strings, die Servernamen, wie sie in `.mcp.json` erscheinen
* **Standard**: nicht gesetzt

Dieses Beispiel genehmigt die Server `memory` und `github` aus der `.mcp.json` des Projekts:

```json settings.json theme={null}
{
  "enabledMcpjsonServers": ["memory", "github"]
}
```

Ein [`disabledMcpjsonServers`](#disabledmcpjsonservers)-Eintrag lehnt einen Server weiterhin ab.

### `managedMcpServers`

Stellen Sie Remote-MCP-Server aus verwalteten Einstellungen für jeden Benutzer bereit. Benutzer behalten die Server, die sie selbst hinzufügen, und können die Server, die Sie bereitstellen, nicht bearbeiten oder entfernen. Erfordert Claude Code v2.1.259 oder später.

* **Geltungsbereich**: [`Managed`](#scopes). Claude Code verwirft den Schlüssel mit einer Warnung in Benutzer-, Projekt- und lokalen Einstellungen und liest ihn nicht in der Code-Registerkarte der Claude Desktop-App bei einer Drittanbieter-Bereitstellung oder in den Cowork-Sitzungen der App, wo Claude Desktop die MCP-Server dieser Sitzungen selbst bereitstellt und sperrt.
* **Typ**: Objekt mit einem Schlüssel pro Servername. Jeder Eintrag hat die `.mcp.json`-Form für einen `http`- oder `sse`-Server: eine erforderliche `https://` `url` und optional `headers`, `oauth` und die anderen HTTP- und SSE-Optionen. Claude Code verwirft Einträge, die die Validierung nicht bestehen, und [Was ein Eintrag enthalten kann](https://code.claude.com/docs/de/managed-mcp.md#what-an-entry-can-contain) listet die Bedingungen auf
* **Standard**: nicht gesetzt, daher stellen verwaltete Einstellungen keine Server bereit

Dieses Beispiel stellt einen HTTP-Server namens `search` bereit:

```json managed-settings.json theme={null}
{
  "managedMcpServers": {
    "search": {
      "type": "http",
      "url": "https://search.example.com/mcp"
    }
  }
}
```

Für Vorrang, wie bereitgestellte Server mit `managed-mcp.json` und den Allow- und Denylists kombiniert werden, und was Benutzer sehen, siehe [Server durch verwaltete Einstellungen bereitstellen](https://code.claude.com/docs/de/managed-mcp.md#provide-servers-through-managed-settings).

## Agenten, Sitzungen und Worktrees

Legen Sie den Standard-Agenten fest, steuern Sie Teamkollegen und sitzungsübergreifendes Messaging, und konfigurieren Sie Worktrees. Siehe [Subagenten](https://code.claude.com/docs/de/sub-agents.md) und [Worktrees](https://code.claude.com/docs/de/worktrees.md).

### `agent`

Führen Sie den Haupt-Thread als benannten [Subagenten](https://code.claude.com/docs/de/sub-agents.md#invoke-subagents-explicitly) aus, damit Claude Code den System-Prompt, die Tool-Einschränkungen und das Modell dieses Subagenten auf Ihre Sitzung anwendet. Derselbe Schlüssel legt den Standard-Agenten für Sitzungen fest, die Sie von `claude agents` aus versenden.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, der Name eines integrierten oder benutzerdefinierten Agenten
* **Standard**: nicht gesetzt, daher wird der Haupt-Thread als Standard-Agent von Claude Code ausgeführt
* **Sitzungsspezifische Überschreibungen**: `--agent` hat Vorrang vor diesem Schlüssel für eine Sitzung

```json settings.json theme={null}
{
  "agent": "code-reviewer"
}
```

Die eigene `settings.json` eines Plugins kann diesen Schlüssel auch bereitstellen; siehe [Versenden Sie Standard-Einstellungen mit Ihrem Plugin](https://code.claude.com/docs/de/plugins/components.md#default-settings).

### `crossSessionInbound`

Wählen Sie, was diese Sitzung mit [Nachrichten tut, die von Ihren anderen Claude Code-Sitzungen ankommen](https://code.claude.com/docs/de/cross-session-messaging.md#control-inbound-messages). Wenn kein Wert zutrifft, entscheidet Claude Code pro Nachricht anhand der Berechtigungsmodus-Klassen der beiden Sitzungen. Erfordert Claude Code v2.1.224 oder später.

* **Geltungsbereich**: [`Any file`](#scopes). Ein Projekt- oder lokaler Wert gilt nur, wenn er strenger ist als der Wert, den verwaltete Einstellungen, das Flag `--settings` oder Benutzereinstellungen vorgeben.
* **Typ**: String, einer von:
  * `"accept"`: Claude Code liefert die Nachricht an Claude
  * `"hold"`: Claude Code zeigt einen Hinweis für die Nachricht an, ohne sie zu liefern
  * `"refuse"`: Claude Code verwirft die Nachricht
* **Standard**: nicht gesetzt, daher entscheidet Claude Code pro Nachricht

```json settings.json theme={null}
{
  "crossSessionInbound": "hold"
}
```

Claude Code liest zuerst verwaltete Einstellungen, dann das Flag `--settings`, dann Benutzereinstellungen und wendet den ersten gefundenen Wert an. `refuse` ist strenger als `hold`, und `hold` ist strenger als `accept`. Wenn keine der vertrauenswürdigen Quellen einen Wert setzt, gilt ein Projekt- oder lokales `hold` oder `refuse` immer noch und ersetzt den Standard pro Nachricht. In Sitzungen mit sitzungsübergreifendem Messaging wird dieser Schlüssel in `/config` als **Messages from your other sessions** angezeigt, was ihn in Benutzereinstellungen schreibt; die Zeile erfordert Claude Code v2.1.232 oder später, und Claude Code blendet sie aus, während das Flag `--settings` oder verwaltete Einstellungen den Schlüssel setzen.

Claude Code [warnt](https://code.claude.com/docs/de/errors.md#crosssessioninbound-must-be-one-of-accept-hold-refuse), wenn Sie einen Wert setzen, den es nicht erkennt. Während dieser Wert in einer Benutzer-, Projekt-, lokalen oder `--settings`-Datei vorhanden ist, hält Claude Code eingehende Nachrichten, auch wenn eine Quelle mit höherer Priorität `accept` setzt. Ein `refuse`, das eine andere Quelle setzt, gilt immer noch. Beheben oder entfernen Sie den Wert, um den Hold zu löschen.

Wenn der nicht erkannte Wert in [verwalteten Einstellungen](https://code.claude.com/docs/de/managed-settings.md) vorhanden ist, behandelt Claude Code ihn stattdessen als `refuse`, bis ein Administrator ihn behebt. Vor v2.1.248 ignorierte Claude Code einen nicht erkannten Wert ohne Warnung.

### `disableAgentView`

Schalten Sie [Hintergrund-Agenten und Agent-Ansicht](https://code.claude.com/docs/de/agent-view.md) aus: `claude agents`, `--bg`, `/background` und den On-Demand-Supervisor. Legen Sie es in [verwalteten Einstellungen](https://code.claude.com/docs/de/managed-settings.md) fest, um es für eine Organisation zu erzwingen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code schaltet `claude agents`, `--bg`, `/background` und den On-Demand-Supervisor aus
  * `false`: Agent-Ansicht ist verfügbar
* **Standard**: nicht gesetzt, daher ist Agent-Ansicht verfügbar
* **Sitzungsspezifische Überschreibungen**: [`CLAUDE_CODE_DISABLE_AGENT_VIEW`](https://code.claude.com/docs/de/env-vars) schaltet Agent-Ansicht für eine Sitzung aus; welcher der beiden sie ausschaltet, der andere kann sie nicht wieder einschalten

```json settings.json theme={null}
{
  "disableAgentView": true
}
```

### `isolatePeerMachines`

Erfordern Sie Ihre ausdrückliche Genehmigung, bevor Claudes `SendMessage` eine Ihrer Sitzungen über diese Maschine hinaus erreicht; siehe [Genehmigung für maschinenübergreifende Nachrichten erforderlich](https://code.claude.com/docs/de/cross-session-messaging.md#require-approval-for-cross-machine-messages). Die Genehmigungsabfrage wird auch im [`bypassPermissions`-Modus](https://code.claude.com/docs/de/permission-modes#skip-all-checks-with-bypasspermissions-mode) angezeigt.

* **Geltungsbereich**: [`Any file`](#scopes). Ein `true` aus einem beliebigen Geltungsbereich gilt, daher kann eine eingecheckte Projektdatei die Anforderung einschalten, aber nicht ausschalten.
* **Typ**: Boolean
  * `true`: Claude Code fragt nach Ihrer Genehmigung, bevor Claudes `SendMessage` eine Ihrer Sitzungen über diese Maschine hinaus erreicht
  * `false`: maschinenübergreifende Nachrichten lösen keine Abfrage aus
* **Standard**: nicht gesetzt, daher lösen maschinenübergreifende Nachrichten keine Abfrage aus

```json settings.json theme={null}
{
  "isolatePeerMachines": true
}
```

Die maschinenübergreifende `SendMessage`-Genehmigung erfordert Claude Code v2.1.224 oder später.

### `processWrapper`

Auf macOS und Linux platzieren Sie einen Corporate-Launcher-Befehl vor den [Hintergrund-Prozessen, die Claude Code startet](https://code.claude.com/docs/de/corporate-launcher.md#what-the-launcher-covers). Claude Code führt den Launcher mit seiner eigenen Befehlszeile angehängt aus, daher muss der Launcher per exec in Claude Code übergehen; siehe [Führen Sie Claude Code hinter einem Corporate Launcher aus](https://code.claude.com/docs/de/corporate-launcher.md) für den Launcher-Vertrag. Erfordert Claude Code v2.1.210 oder später.

* **Geltungsbereich**: [`User or managed`](#scopes)
* **Typ**: String, der Launcher-Befehl als argv-Präfix, z. B. ein absoluter Pfad mit optionalen Argumenten
* **Standard**: nicht gesetzt, daher starten Hintergrund-Prozesse unverpackt
* **Sitzungsspezifische Überschreibungen**: [`CLAUDE_CODE_PROCESS_WRAPPER`](https://code.claude.com/docs/de/env-vars) hat Vorrang vor diesem Schlüssel für eine Sitzung

```json settings.json theme={null}
{
  "processWrapper": "/opt/corp/launcher --profile claude"
}
```

Claude Code ignoriert den Launcher unter Windows und startet jeden Prozess unverpackt. Erfordert Claude Code v2.1.210 oder später.

### `teammateMode`

Wählen Sie, wo Claude Code [Agent-Team](https://code.claude.com/docs/de/agent-teams.md)-Teamkollegen anzeigt: in Ihrem Haupt-Terminal-Bereich oder in geteilten Bereichen, wenn Ihr Terminal diese unterstützt. Siehe [Wählen Sie einen Anzeigemodus](https://code.claude.com/docs/de/agent-teams.md#choose-a-display-mode).

* **Geltungsbereich**: [`Any file`](#scopes). Claude Code liest auch einen Wert, der von älteren Versionen in `~/.claude.json` hinterlassen wurde.
* **Typ**: String, einer von:
  * `"in-process"`: Teamkollegen werden in Ihrem Haupt-Terminal-Bereich ausgeführt
  * `"auto"`: geteilte Bereiche, wenn Sie sich in tmux befinden, oder in iTerm2 mit `it2` auf Ihrem `PATH` oder tmux installiert; ansonsten in-process
  * `"tmux"`: geteilte Bereiche mit tmux oder iTerm2, erkannt von Ihrem Terminal
  * `"iterm2"`: iTerm2 native geteilte Bereiche über die `it2` CLI
* **Standard**: `"in-process"`
* **Sitzungsspezifische Überschreibungen**: `--teammate-mode` hat Vorrang vor diesem Schlüssel für eine Sitzung

```json settings.json theme={null}
{
  "teammateMode": "auto"
}
```

### `worktree`

Konfigurieren Sie, wie Claude Code [Git-Worktrees](https://code.claude.com/docs/de/worktrees.md) für `--worktree`, das Tool `EnterWorktree` und isolierte Subagenten und Hintergrund-Sitzungen erstellt und verwaltet.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Objekt mit `baseRef`, `symlinkDirectories`, `sparsePaths` und `bgIsolation`
* **Standard**: nicht gesetzt

Dieses Beispiel verzweigt neue Worktrees von Ihrem aktuellen `HEAD` und erstellt Symlinks für `node_modules` in jedem:

```json settings.json theme={null}
{
  "worktree": {
    "baseRef": "head",
    "symlinkDirectories": ["node_modules"]
  }
}
```

Um gitignorierte Dateien wie `.env` in neue Worktrees zu kopieren, fügen Sie stattdessen eine [`.worktreeinclude`-Datei](https://code.claude.com/docs/de/worktrees#copy-gitignored-files-into-worktrees) zu Ihrem Projekt-Root hinzu.

### `worktree.baseRef`

Wählen Sie, von welchem Ref neue Worktrees verzweigt werden. `"fresh"` verzweigt von `origin/<default-branch>` für einen sauberen Baum, der dem Remote entspricht; `"head"` verzweigt von Ihrem aktuellen lokalen `HEAD`, daher sind nicht gepushte Commits und Feature-Branch-Status im Worktree vorhanden.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, einer von:
  * `"fresh"`: neue Worktrees verzweigen von `origin/<default-branch>`
  * `"head"`: neue Worktrees verzweigen von Ihrem aktuellen lokalen `HEAD`, einschließlich nicht gepushter Commits
* **Standard**: `"fresh"`

```json settings.json theme={null}
{
  "worktree": {
    "baseRef": "head"
  }
}
```

Innerhalb eines verknüpften Worktrees wird `"head"` zum `HEAD` dieses Worktrees aufgelöst, nicht zum `HEAD` des Haupt-Checkouts.

### `worktree.symlinkDirectories`

Erstellen Sie Symlinks für Verzeichnisse aus dem Haupt-Repository in jeden Worktree, damit Sie große Verzeichnisse nicht auf der Festplatte duplizieren.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Array von Strings, Verzeichnispfade relativ zum Repository-Root
* **Standard**: nicht gesetzt, daher erstellt Claude Code keine Symlinks für Verzeichnisse

Dieses Beispiel erstellt Symlinks für `node_modules` und `.cache` aus dem Haupt-Repository in jeden neuen Worktree:

```json settings.json theme={null}
{
  "worktree": {
    "symlinkDirectories": ["node_modules", ".cache"]
  }
}
```

### `worktree.sparsePaths`

Checken Sie nur die aufgelisteten Verzeichnisse in jedem Worktree über Git Sparse-Checkout aus. Claude Code schreibt nur diese Verzeichnisse plus Root-Level-Dateien auf die Festplatte, was in großen Monorepos schneller ist; siehe [Checken Sie nur die Verzeichnisse aus, die Sie benötigen](https://code.claude.com/docs/de/large-codebases.md#check-out-only-the-directories-you-need).

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Array von Strings, Verzeichnispfade relativ zum Repository-Root
* **Standard**: nicht gesetzt, daher checkt jeder Worktree den ganzen Baum aus

Dieses Beispiel checkt nur `packages/my-app` und `shared/utils` plus Root-Level-Dateien in jedem Worktree aus:

```json settings.json theme={null}
{
  "worktree": {
    "sparsePaths": ["packages/my-app", "shared/utils"]
  }
}
```

Während ein Sparse-Worktree vorhanden ist, aktiviert Git `extensions.worktreeConfig` in der gemeinsamen `.git/config` des Repositorys.

### `worktree.bgIsolation`

Wählen Sie, wie [Hintergrund-Sitzungen](https://code.claude.com/docs/de/agent-view.md#how-file-edits-are-isolated) ihre Datei-Änderungen isolieren. Wenn Sie eine Sitzung mit `←` oder `/background` in den Hintergrund verschoben haben, bearbeitet diese Sitzung Dateien an Ort und Stelle, unabhängig davon, was dieser Schlüssel angibt. Mit `"worktree"` blockiert Claude Code `Edit` und `Write` im Haupt-Checkout, bis die Sitzung `EnterWorktree` aufruft; mit `"none"` bearbeiten Hintergrund-Jobs die Working Copy direkt. Setzen Sie `"none"` für ein Repository, in dem Git-Worktrees unpraktisch sind.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: String, einer von:
  * `"worktree"`: Claude Code blockiert `Edit` und `Write` im Haupt-Checkout, bis die Sitzung `EnterWorktree` aufruft
  * `"none"`: Hintergrund-Jobs bearbeiten die Working Copy direkt
* **Standard**: `"worktree"`

```json settings.json theme={null}
{
  "worktree": {
    "bgIsolation": "none"
  }
}
```

Außerhalb eines Git-Repositorys gibt ein [`WorktreeCreate`-Hook](https://code.claude.com/docs/de/worktrees#non-git-version-control), der fehlschlägt, die Blockade frei, damit die Sitzung das Arbeitsverzeichnis an Ort und Stelle bearbeiten kann.

### `worktree.location`

Wählen Sie den Ordner auf einem Remote-Rechner, in dem [Desktop-SSH-Sitzungen](https://code.claude.com/docs/de/desktop.md#choose-where-ssh-session-worktrees-go) ihre Worktrees erstellen, anstelle von `<project-root>/.claude/worktrees/`. Nur die Desktop-App liest diesen Schlüssel: `--worktree`, das Tool `EnterWorktree`, isolierte Subagenten und Hintergrund-Sitzungen ignorieren ihn. Erfordert Claude Desktop v1.44121.0 oder später.

* **Geltungsbereich**: [`User`](#scopes), in `~/.claude/settings.json` auf dem Remote-Rechner
* **Typ**: String, ein absoluter Pfad oder ein Pfad, der mit `~/` beginnt
* **Standard**: nicht gesetzt, daher werden Worktrees innerhalb des Projekts angelegt

Dieses Beispiel setzt den Ordner auf `~/worktrees`:

```json settings.json theme={null}
{
  "worktree": {
    "location": "~/worktrees"
  }
}
```

Ein **Worktree folder**, der in Desktop für die SSH-Verbindung festgelegt ist, hat Vorrang. Wenn Ihre Organisation einschränkt, welche Ordner Sitzungen verwenden dürfen, belässt Desktop die Worktrees innerhalb des Projekts.

## Remote, Desktop und Benachrichtigungen

Konfigurieren Sie Remote Control, Cloud-Umgebungen, die Desktop-App und die Benachrichtigungen, die Claude Code sendet, wenn es Sie braucht. Siehe [Remote Control](https://code.claude.com/docs/de/remote-control.md).

### `agentPushNotifEnabled`

Erlauben Sie Claude, eine Push-Benachrichtigung an Ihr Telefon zu senden, wenn es entscheidet, dass dies sinnvoll ist, beispielsweise wenn eine lange Aufgabe abgeschlossen ist. Claude kann eine solche Benachrichtigung senden, während [Remote Control](https://code.claude.com/docs/de/remote-control.md) verbunden ist. Wird in `/config` als **Push wenn Claude entscheidet** angezeigt. Wenn Sie den Wert dort ändern, speichert Claude Code ihn auch in Ihrem Konto.

* **Geltungsbereich**: [`Any file`](#scopes). Claude Code liest auch einen Wert, der von älteren Versionen in `~/.claude.json` hinterlassen wurde.
* **Typ**: Boolean
  * `true`: Claude kann eine Push-Benachrichtigung an Ihr Telefon senden, wenn es entscheidet, dass dies sinnvoll ist
  * `false`: Claude sendet diese Benachrichtigungen nicht
* **Standard**: `false`

```json settings.json theme={null}
{
  "agentPushNotifEnabled": true
}
```

Wenn Sie Sitzungen unter einem [`claude remote-control`](https://code.claude.com/docs/de/remote-control#start-a-remote-control-session)-Server ausführen, folgen diese dem in Ihrem Konto gespeicherten Wert statt diesem Schlüssel. Um diesen Wert zu ändern, führen Sie `/config` in einer Claude Code-Sitzung in Ihrem Terminal aus und schalten Sie **Push wenn Claude entscheidet** ein oder aus. Wenn der Schalter bereits den gewünschten Wert anzeigt, ändern Sie ihn und stellen Sie ihn anschließend wieder zurück, damit Claude Code diesen Wert in Ihrem Konto speichert.

Siehe [Mobile Push-Benachrichtigungen](https://code.claude.com/docs/de/remote-control.md#mobile-push-notifications).

### `awaySummaryEnabled`

Zeigen Sie eine einzeilige Sitzungszusammenfassung an, wenn Sie nach einigen Minuten Abwesenheit zum Terminal zurückkehren. Setzen Sie es auf `false` oder deaktivieren Sie **Sitzungszusammenfassung** in `/config`, um die Zusammenfassung zu deaktivieren.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Sie sehen eine einzeilige Sitzungszusammenfassung, wenn Sie nach einigen Minuten Abwesenheit zurückkehren
  * `false`: Claude Code zeigt keine Zusammenfassung an
* **Standard**: nicht gesetzt, daher ist die Zusammenfassung aktiviert
* **Sitzungsspezifische Überschreibungen**: [`CLAUDE_CODE_ENABLE_AWAY_SUMMARY`](https://code.claude.com/docs/de/env-vars) hat Vorrang vor diesem Schlüssel für eine Sitzung, in beide Richtungen

```json settings.json theme={null}
{
  "awaySummaryEnabled": false
}
```

Claude Code zeigt die Zusammenfassung niemals im nicht interaktiven Modus an.

### `disableArtifact`

> [!WARNING]
>
> Veraltet und ersetzt durch [`enableArtifact`](#enableartifact). Claude Code berücksichtigt weiterhin `disableArtifact: true` als gleichwertig mit `enableArtifact: false` und ignoriert `disableArtifact: false`.

Verwenden Sie stattdessen [`enableArtifact`](#enableartifact), um das [Artifact](https://code.claude.com/docs/de/artifacts.md)-Tool auszuschalten, das Sitzungsausgaben als private Webseite auf claude.ai veröffentlicht. Wenn Sie die Zeile **Artifacts** in `/config` ausschalten, schreibt Claude Code `enableArtifact` in Ihre Benutzereinstellungen und löscht diesen Schlüssel.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code schaltet das Artifact-Tool für jede Sitzung aus, auf die die Datei zutrifft, und keine andere Datei schaltet es wieder ein
  * `false`: ignoriert; um das Tool eingeschaltet zu lassen, entfernen Sie den Schlüssel
* **Standard**: nicht gesetzt, daher folgt das Tool Ihrer Konto-[Verfügbarkeit](https://code.claude.com/docs/de/artifacts.md#availability)
* **Sitzungsspezifische Überschreibungen**: [`CLAUDE_CODE_DISABLE_ARTIFACT`](https://code.claude.com/docs/de/env-vars) auf `1` gesetzt schaltet das Tool für eine Sitzung aus

```json settings.json theme={null}
{
  "disableArtifact": true
}
```

[Artifacts deaktivieren](https://code.claude.com/docs/de/artifacts.md#disable-artifacts) listet alle Möglichkeiten auf, das Tool auszuschalten.

### `disableDeepLinkRegistration`

Verhindern Sie, dass Claude Code den `claude-cli://`-Protokoll-Handler beim Betriebssystem registriert, was es ansonsten nach dem ersten Prompt einer interaktiven Sitzung tut. [Deep Links](https://code.claude.com/docs/de/deep-links.md) ermöglichen es externen Tools, eine Claude Code-Sitzung mit einem vorausgefüllten Prompt zu öffnen. Setzen Sie dies in Umgebungen, in denen die Registrierung von Protokoll-Handlern eingeschränkt oder separat verwaltet wird.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: die Zeichenkette `"disable"`
* **Standard**: nicht gesetzt, daher registriert Claude Code den Handler

```json settings.json theme={null}
{
  "disableDeepLinkRegistration": "disable"
}
```

### `disableDesktopLocalSessions`

Schalten Sie Code-Sitzungen aus, die auf dem Gerät in der [Desktop-App](https://code.claude.com/docs/de/desktop.md#local-sessions-on-managed-devices) ausgeführt werden, für Bereitstellungen, bei denen Entwickler auf Remote-Maschinen über SSH arbeiten sollten. Wenn der Schlüssel auf `true` gesetzt ist, sehen Benutzer in der Code-Registerkarte Folgendes:

* **Umgebungsauswahl**: Der Eintrag für den Computer des Benutzers ist ausgegraut und nicht auswählbar, mit dem Tooltip **Disabled by your organization**. Unter Windows ist der WSL-Eintrag auf die gleiche Weise ausgegraut, obwohl [separat geregelt wird](https://code.claude.com/docs/de/admin-setup.md#wsl-sessions-in-claude-code-desktop), ob WSL-Sitzungen auf einem verwalteten Gerät überhaupt ausgeführt werden.
* **Neue Sitzungen**: werden standardmäßig auf die erste [SSH-Verbindung](https://code.claude.com/docs/de/desktop.md#ssh-sessions) gesetzt, falls eine konfiguriert ist
* **Sitzungen auf dem Gerät**: Die App weigert sich, eine Sitzung auf dem Gerät zu starten oder fortzusetzen, einschließlich einer SSH-Verbindung zurück zur gleichen Maschine
* **SSH-Sitzungen zu anderen Hosts und Cloud-Sitzungen**: nicht betroffen

Die Desktop-App liest diesen Schlüssel; die Terminal-CLI ignoriert ihn. Erfordert Claude Desktop v1.37937.0 oder später.

* **Geltungsbereich**: [`Managed`](#scopes). Standardmäßig liest die Desktop-App den Schlüssel aus [einer verwalteten Quelle](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources).
* **Typ**: Boolean; nur der JSON-Boolean `true` hat Auswirkungen
  * `true`: die Desktop-App bietet keine Code-Sitzungen auf dem Gerät an; vorhandene lokale Sitzungen bleiben aufgelistet, können aber nicht fortgesetzt werden
  * `false`: lokale Sitzungen bleiben verfügbar
* **Standard**: nicht gesetzt, daher sind lokale Sitzungen verfügbar

```json managed-settings.json theme={null}
{
  "disableDesktopLocalSessions": true
}
```

Die Desktop-App ignoriert jeden anderen Wert, und ein Wert, der kein Boolean ist, wie die Zeichenkette `"true"` oder `1`, protokolliert auch eine Warnung. Kombinieren Sie ihn mit [`sshConfigs`](#sshconfigs), damit Benutzer auf einer funktionierenden Verbindung landen, und mit [`sshHostAllowlist`](#sshhostallowlist), um zu begrenzen, welche Hosts sie erreichen können. Siehe [Lokale Sitzungen auf verwalteten Geräten](https://code.claude.com/docs/de/desktop.md#local-sessions-on-managed-devices).

Claude Desktop versorgt Code-Sitzungen mit einer Richtlinie, die sich aus Ihrer Desktop-Konfiguration ergibt, beispielsweise die Egress-Allowlist, die Dateisystem-Sandbox und die MCP-Einschränkungen in Bereitstellungen von Drittanbietern. Claude Code ignoriert diese übergeordneten Einstellungen, wenn eine [Admin-Quelle](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources) vorhanden ist: servergesteuerte Einstellungen, eine MDM- oder Betriebssystem-Richtlinie oder eine verwaltete Einstellungsdatei. Die Bereitstellung dieses Schlüssels durch eine dieser Methoden auf einem Gerät, das zuvor keine hatte, wie in Bereitstellungen von Drittanbietern, stoppt daher die Anwendung der Desktop-abgeleiteten Richtlinien. [Lassen Sie einen Embedding-Host eine Richtlinie hinzufügen](https://code.claude.com/docs/de/managed-settings.md#let-an-embedding-host-add-policy) behandelt, wann übergeordnete Einstellungen noch zusammengeführt werden können; dies gilt für jeden Schlüssel, den Sie auf diese Weise bereitstellen, nicht nur diesen.

### `disableRemoteControl`

Schalten Sie [Remote Control](https://code.claude.com/docs/de/remote-control.md) aus: Claude Code lehnt dann `claude remote-control`, das Flag `--remote-control`, Auto-Start und den In-Session-Toggle ab und meldet, dass die Richtlinie Ihrer Organisation es deaktiviert hat. Platzieren Sie es in [verwalteten Einstellungen](https://code.claude.com/docs/de/managed-settings.md) für die MDM-Durchsetzung pro Gerät.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code lehnt `claude remote-control`, das Flag `--remote-control`, Auto-Start und den In-Session-Toggle ab
  * `false`: Remote Control bleibt verfügbar
* **Standard**: `false`

```json settings.json theme={null}
{
  "disableRemoteControl": true
}
```

### `enableArtifact`

Schalten Sie das [Artifact](https://code.claude.com/docs/de/artifacts.md)-Tool aus, das Sitzungsausgaben als private Webseite auf claude.ai veröffentlicht. Wenn Sie die Zeile **Artifacts** in `/config` ausschalten, schreibt Claude Code diesen Schlüssel in Ihre Benutzereinstellungen, daher bearbeiten Sie ihn normalerweise nicht von Hand.

* **Geltungsbereich**: [`Any file`](#scopes). Jede Datei kann das Tool ausschalten, und keine kann es wieder einschalten.
* **Typ**: Boolean
  * `false`: Claude Code schaltet das Artifact-Tool für jede Sitzung aus, auf die die Datei zutrifft
  * `true`: dasselbe wie das Weglassen des Schlüssels, da es niemals ein `false` aus einer anderen Datei, von [`CLAUDE_CODE_DISABLE_ARTIFACT`](https://code.claude.com/docs/de/env-vars) oder von der [Admin-Einstellung](https://code.claude.com/docs/de/artifacts.md#manage-artifacts-for-your-organization) Ihrer Organisation überschreibt
* **Standard**: nicht gesetzt, daher folgt das Tool Ihrer Konto-[Verfügbarkeit](https://code.claude.com/docs/de/artifacts.md#availability)

```json settings.json theme={null}
{
  "enableArtifact": false
}
```

Während eine andere Quelle als Ihre eigenen Benutzereinstellungen das Tool ausgeschaltet hält, versteckt Claude Code die Zeile **Artifacts** in `/config`, da das Einschalten dort nichts ändern würde. [Artifacts deaktivieren](https://code.claude.com/docs/de/artifacts.md#disable-artifacts) listet alle Möglichkeiten auf, das Tool auszuschalten.

### `inputNeededNotifEnabled`

Erhalten Sie eine Push-Benachrichtigung auf Ihrem Telefon, wenn eine Berechtigungsabfrage oder Frage auf Ihre Eingabe wartet. Claude Code sendet diese nur, während [Remote Control](https://code.claude.com/docs/de/remote-control.md) verbunden ist. Wird in `/config` als **Push wenn Aktionen erforderlich sind** angezeigt.

* **Geltungsbereich**: [`Any file`](#scopes). Claude Code liest auch einen Wert, der von älteren Versionen in `~/.claude.json` hinterlassen wurde.
* **Typ**: Boolean
  * `true`: Sie erhalten eine Push-Benachrichtigung auf Ihrem Telefon, wenn eine Berechtigungsabfrage oder Frage wartet, während Remote Control verbunden ist
  * `false`: Claude Code sendet keine solchen Benachrichtigungen
* **Standard**: `false`

```json settings.json theme={null}
{
  "inputNeededNotifEnabled": true
}
```

Siehe [Mobile Push-Benachrichtigungen](https://code.claude.com/docs/de/remote-control.md#mobile-push-notifications).

### `preferredNotifChannel`

Wählen Sie, wie Claude Code Sie benachrichtigt, wenn eine Aufgabe abgeschlossen ist oder eine Berechtigungsabfrage wartet. Die [Benachrichtigungen eines Mods](https://code.claude.com/docs/de/plugins/mods/api.md#show-something-without-starting-a-turn) verwenden dieselbe Einstellung. Wird in `/config` als **Lokale Benachrichtigungen** angezeigt.

* **Geltungsbereich**: [`Any file`](#scopes). Claude Code liest auch einen Wert, der von älteren Versionen in `~/.claude.json` hinterlassen wurde.
* **Typ**: Zeichenkette, eine von:
  * `"auto"`: Claude Code sendet eine Desktop-Benachrichtigung in iTerm2, Ghostty und Kitty, läutet die Glocke in Terminal.app nur, wenn dessen hörbare Glocke ausgeschaltet ist, und tut anderswo nichts
  * `"terminal_bell"`: Claude Code läutet das Glockensignal in jedem Terminal
  * `"iterm2"`: Claude Code sendet eine iTerm2-Desktop-Benachrichtigung
  * `"iterm2_with_bell"`: Claude Code sendet eine iTerm2-Desktop-Benachrichtigung und läutet die Glocke
  * `"kitty"`: Claude Code sendet eine Kitty-Desktop-Benachrichtigung
  * `"ghostty"`: Claude Code sendet eine Ghostty-Desktop-Benachrichtigung
  * `"notifications_disabled"`: Claude Code sendet keine Benachrichtigung
* **Standard**: `"auto"`

```json settings.json theme={null}
{
  "preferredNotifChannel": "terminal_bell"
}
```

Mit `"auto"` sendet Claude Code eine Desktop-Benachrichtigung in iTerm2, Ghostty und Kitty. In Terminal.app läutet es das Glockensignal nur, wenn Sie die hörbare Glocke von Terminal ausgeschaltet haben, und in anderen Terminals tut es nichts. Setzen Sie `"terminal_bell"`, um das Glockensignal in jedem Terminal zu läuten. Siehe [Erhalten Sie eine Terminal-Glocke oder Benachrichtigung](https://code.claude.com/docs/de/terminal-config.md#get-a-terminal-bell-or-notification).

### `remote.defaultEnvironmentId`

Wählen Sie die Standard-[Cloud-Umgebung](https://code.claude.com/docs/de/cloud-environments.md) für Cloud-Sitzungen, die Sie von der CLI aus erstellen, z. B. mit `claude --cloud`. Claude Code schreibt diesen Schlüssel in Ihre Benutzereinstellungen, wenn Sie eine Umgebung mit [`/remote-env`](https://code.claude.com/docs/de/cloud-environments#select-an-environment-from-the-cli) auswählen.

* **Geltungsbereich**: [`Any file`](#scopes). Für eine selbstgehostete Umgebungs-ID nur Benutzer- oder verwaltete Einstellungen oder das Flag `--settings`.
* **Typ**: Zeichenkette, eine Umgebungs-ID wie `env_...` oder `ccpool_...`
* **Standard**: nicht gesetzt, daher verwendet Claude Code die von Anthropic gehostete Umgebung, wenn Ihre Liste eine hat, und ansonsten die erste Umgebung in Ihrer Liste, die keine [Remote-Control-Bridge-Umgebung](https://code.claude.com/docs/de/cloud-environments.md#the-default-environment) ist, oder die erste Umgebung, wenn jede eine Bridge-Umgebung ist
* **Sitzungsspezifische Überschreibungen**: `--environment` hat Vorrang vor diesem Schlüssel für die eine Cloud-Sitzung, die es erstellt

```json settings.json theme={null}
{
  "remote": {
    "defaultEnvironmentId": "env_0123abcd"
  }
}
```

Eine von Anthropic gehostete Umgebungs-ID, die mit `env_` beginnt, folgt der Standard-Rangfolge der Einstellungen, daher überschreibt ein Wert in den Projekteinstellungen eines Repositorys Ihre Auswahl auf Benutzerebene. Eine [selbstgehostete Umgebungs](https://code.claude.com/docs/de/self-hosted-environments)-ID, die mit `ccpool_` beginnt, wird nur aus Benutzereinstellungen, verwalteten Einstellungen und dem Flag `--settings` berücksichtigt; Claude Code ignoriert eine in den Projekt- oder lokalen Einstellungen eines Repositorys, und `/remote-env` zeigt, welcher Wert ignoriert wurde, daher kann eine eingecheckte Datei Sitzungen nicht auf eine selbstgehostete Umgebung lenken, die Sie nicht ausgewählt haben.

### `remoteControlAtStartup`

Verbinden Sie [Remote Control](https://code.claude.com/docs/de/remote-control.md) automatisch, wenn jede interaktive Sitzung startet, anstatt auf `/remote-control` zu warten. Setzen Sie es auf `true`, um Auto-Connect einzuschalten, `false`, um es auszuschalten. Wird in `/config` als **Remote Control für alle Sitzungen aktivieren** angezeigt.

* **Geltungsbereich**: [`Any file`](#scopes). Claude Code liest auch einen Wert, der von älteren Versionen in `~/.claude.json` hinterlassen wurde.
* **Typ**: Boolean
  * `true`: Claude Code verbindet Remote Control automatisch, wenn jede interaktive Sitzung startet
  * `false`: Claude Code wartet auf `/remote-control`
* **Standard**: nicht gesetzt, daher gilt der [Auto-Connect-Standard](https://code.claude.com/docs/de/remote-control.md#enable-remote-control-for-all-sessions)
* **Sitzungsspezifische Überschreibungen**: `--remote-control` schaltet Remote Control für eine Sitzung ein, auch wenn dieser Schlüssel `false` ist, und kein Flag schaltet es für eine Sitzung aus

```json settings.json theme={null}
{
  "remoteControlAtStartup": true
}
```

Claude Code ignoriert ein `true` aus Projekt- oder lokalen Einstellungen, daher kann ein Repository Auto-Connect für seinen Checkout ausschalten, aber nicht einschalten. Für das vollständige Verhalten pro Geltungsbereich siehe [Remote Control für alle Sitzungen aktivieren](https://code.claude.com/docs/de/remote-control.md#enable-remote-control-for-all-sessions) und die [Sicherheitsschlüssel, bei denen der strengere Wert gilt](https://code.claude.com/docs/de/settings.md#security-keys-where-the-stricter-value-applies).

### `sshConfigs`

Fügen Sie SSH-Verbindungen zur [Desktop](https://code.claude.com/docs/de/desktop.md#pre-configure-ssh-connections-for-your-team)-Umgebungsauswahl hinzu. Administratoren verwenden `sshConfigs`, um gemeinsame Verbindungen an ein Team zu verteilen. Benutzer können eine verwaltete Verbindung auswählen und [ihren eigenen **Worktree-Ordner**](https://code.claude.com/docs/de/desktop.md#set-the-worktree-folder-on-an-existing-connection) dafür festlegen. Die anderen Felder der Verbindung können sie in der App nicht bearbeiten, und löschen können sie die Verbindung dort ebenfalls nicht.

* **Geltungsbereich**: [`User or managed`](#scopes). Die Desktop-App liest diesen Schlüssel. Standardmäßig liest sie verwaltete Verbindungen aus [einer verwalteten Quelle](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources).
* **Typ**: Array von Objekten, jedes mit erforderlichen `id`, `name` und `sshHost` und optionalen `sshPort` und `sshIdentityFile`
* **Standard**: nicht gesetzt

Dieses Beispiel fügt eine Verbindung namens `Dev VM` hinzu, die sich mit `user@dev.example.com` verbindet:

```json settings.json theme={null}
{
  "sshConfigs": [
    {
      "id": "dev-vm",
      "name": "Dev VM",
      "sshHost": "user@dev.example.com"
    }
  ]
}
```

### `sshHostAllowlist`

Begrenzen Sie die Hosts, mit denen sich eine [Desktop-SSH-Sitzung](https://code.claude.com/docs/de/desktop.md#restrict-which-ssh-hosts-users-can-connect-to) verbinden kann. Nur die Desktop-App liest diesen Schlüssel; die CLI nicht. Bei Mustern wird die Groß-/Kleinschreibung nicht beachtet: `*` passt auf jeden Host, `*.example.com` passt auf `example.com` und jede Subdomain, und alles andere ist eine genaue Übereinstimmung mit dem Hostnamen nach `~/.ssh/config`-Auflösung. Ein leeres Array schaltet SSH-Sitzungen aus.

Ab Claude Desktop v3.1623.0 müssen auch die [Jump-Hosts](https://code.claude.com/docs/de/desktop.md#allow-jump-hosts) einer Sitzung auf ein Muster passen.

* **Geltungsbereich**: [`Managed`](#scopes). Standardmäßig liest Desktop den Schlüssel aus [einer verwalteten Quelle](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources).
* **Typ**: Array von Hostnamen-Mustern
* **Standard**: nicht gesetzt, daher ist jeder Host erlaubt

Dieses Beispiel erlaubt `devboxes.example.com` und seine Subdomains, plus den genauen Host `bastion.example.com`:

```json managed-settings.json theme={null}
{
  "sshHostAllowlist": ["*.devboxes.example.com", "bastion.example.com"]
}
```

Ein Wert, den Desktop nicht als Liste von Hosts lesen kann, etwa `true` oder ein Objekt, gilt als leeres Array, bis Sie ihn korrigieren, mit Ausnahme von `null`, das als nicht gesetzt gilt. Erfordert Claude Desktop v2.26454.0 oder später.

Wenn Sie [`managedSourcesBehavior`](#managedsourcesbehavior) in Ihrer ranghöchsten Quelle auf `"merge"` setzen, führt Desktop die Listen aus jeder [Admin-Quelle](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources) zusammen und erlaubt einen Host, der auf eine davon passt. Wenn Sie in einer Quelle ein leeres Array festlegen, bleiben SSH-Sitzungen für die Hosts eingeschaltet, die eine andere Quelle auflistet.

### `sshHostCommands`

Fügen Sie der [Desktop](https://code.claude.com/docs/de/desktop.md#create-an-ssh-connection-from-a-command)-Umgebungsauswahl SSH-Verbindungen hinzu, deren Host von einem Befehl stammt. Wenn Sie eine Verbindung erstellen oder ihren Host ersetzen, führt Desktop den Befehl des Eintrags auf Ihrem Computer aus und verbindet sich mit dem Host, den der Befehl ausgibt. Erfordert Claude Desktop v3.6556.0 oder später unter macOS oder Linux, angemeldet mit einem Claude-Konto.

* **Geltungsbereich**: [`User or managed`](#scopes). Nur die Desktop-App liest diesen Schlüssel. Sie liest verwaltete Einträge aus [einer verwalteten Einstellungsdatei oder MDM-Richtlinie](https://code.claude.com/docs/de/desktop.md#distribute-commands-to-your-team) auf dem Computer und ignoriert den Schlüssel in [servergesteuerten Einstellungen](https://code.claude.com/docs/de/server-managed-settings.md).
* **Typ**: Array von Objekten, jedes mit erforderlichen `id`, `name` und `command` und optionalen `sshIdentityFile` und `startDirectory`. Desktop startet `command` ohne Shell, daher [schreiben Sie ihn als Programm mit einfachen Argumenten](https://code.claude.com/docs/de/desktop.md#write-the-command).
* **Standard**: nicht gesetzt

Dieses Beispiel fügt eine Verbindung namens `Dev box` hinzu, wobei `acme-dev create` für Ihr eigenes Tool steht:

```json settings.json theme={null}
{
  "sshHostCommands": [
    {
      "id": "devbox",
      "name": "Dev box",
      "command": "acme-dev create"
    }
  ]
}
```

Vor Claude Code v2.1.307 lehnte das Edit-Tool eine Änderung, die diesen Schlüssel zu einer gültigen Einstellungsdatei hinzufügte, mit dem Fehler `Unrecognized field: sshHostCommands` ab. Fügen Sie den Schlüssel bei diesen Versionen stattdessen in einem Texteditor hinzu; Claude Code lädt eine Datei, die den Schlüssel enthält. In Desktop ist die [Claude Code-Version der Code-Registerkarte](https://code.claude.com/docs/de/desktop.md#claude-code-version-in-the-code-tab) maßgeblich, nicht die Ihres Terminals.

## Authentifizierung und Anbieter

Stellen Sie Anmeldedaten über Hilfsskripte bereit und erzwingen Sie für Organisationen eine Anmeldemethode oder Organisation. Siehe [Authentifizierung](https://code.claude.com/docs/de/authentication.md).

### `allowedProviders`

Listen Sie die Dienste auf, über die ein Computer Claude erreichen darf, etwa die Anthropic API, Amazon Bedrock oder ein LLM-Gateway. Eine Sitzung bei einem nicht aufgeführten Anbieter wird beim Start, bei der Anmeldung und beim nächsten Kontakt mit der API abgelehnt, sodass auch ein Wechsel zu einem nicht aufgeführten Anbieter während der Sitzung abgelehnt wird. Die [Ablehnungsmeldung](https://code.claude.com/docs/de/errors.md#managed-settings-dont-allow-this-api-provider) nennt, wodurch der Anbieter ausgewählt wurde, und die Schritte zum Fortfahren. Erfordert Claude Code v2.1.285 oder später.

* **Geltungsbereich**: [`Managed`](#scopes). Eine Liste, die die eigenen Admin-Quellen des Computers festlegen, also MDM-Richtlinien und verwaltete Einstellungsdateien, gilt weiterhin, wenn auch server-verwaltete Einstellungen eine Liste liefern: Eine Sitzung darf dann nur die Anbieter verwenden, die auf beiden Listen stehen, sodass eine server-verwaltete Liste die Zulassungen des Computers einschränken, aber nie erweitern kann. Welches `allowedProviders` einer Quelle auf dem Computer zählt, richtet sich danach, [wie Claude Code verwaltete Quellen kombiniert](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources). Eine ausschließlich über server-verwaltete Einstellungen gelieferte Liste erreicht nur die Sitzungen, die [server-verwaltete Einstellungen abrufen](https://code.claude.com/docs/de/server-managed-settings.md#platform-availability).
* **Typ**: Array von Strings, jeweils einer von:
  * `"anthropic"`: die Anthropic API auf dem eigenen Host von Anthropic, über eine claude.ai- oder Console-Anmeldung oder einen API-Schlüssel. Kombinieren Sie ihn mit [`forceLoginMethod`](#forceloginmethod) oder [`forceLoginOrgUUID`](#forceloginorguuid), um zusätzlich die Anmeldung einzuschränken
  * `"bedrock"`: [Amazon Bedrock](https://code.claude.com/docs/de/amazon-bedrock.md)
  * `"vertex"`: [Google Cloud's Agent Platform](https://code.claude.com/docs/de/google-vertex-ai.md), früher Vertex AI
  * `"foundry"`: [Microsoft Foundry](https://code.claude.com/docs/de/microsoft-foundry.md)
  * `"anthropicAws"`: [Claude Platform on AWS](https://code.claude.com/docs/de/claude-platform-on-aws.md)
  * `"mantle"`: der Amazon Bedrock [Mantle-Endpunkt](https://code.claude.com/docs/de/amazon-bedrock.md#use-the-mantle-endpoint). Eine Sitzung, die [Mantle parallel zur Invoke API ausführt](https://code.claude.com/docs/de/amazon-bedrock.md#run-mantle-alongside-the-invoke-api), verwendet beide Anbieter; listen Sie dafür `"bedrock"` und `"mantle"` gemeinsam auf
  * `"customEndpoint"`: die Anthropic API oder die API eines Cloud-Anbieters, die an einen anderen Host gesendet wird, etwa ein [LLM-Gateway](https://code.claude.com/docs/de/llm-gateway), das über `ANTHROPIC_BASE_URL` oder über die Endpunktvariable eines Anbieters wie `ANTHROPIC_BEDROCK_BASE_URL` angegeben ist. Claude Code lässt ihn nur für genau den Wert zu, den ein verwalteter [`env`](#env)-Block festlegt
  * `"gateway"`: eine [Cloud-Gateway](https://code.claude.com/docs/de/claude-apps-gateway)-Anmeldung
* **Standard**: nicht gesetzt, daher kann jeder Anbieter verwendet werden

```json managed-settings.json theme={null}
{
  "allowedProviders": ["anthropic", "bedrock"]
}
```

Der Eintrag eines Cloud-Anbieters bezeichnet den eigenen Dienst dieses Anbieters, einschließlich seiner regionalen, FIPS- und privaten Endpunkte.

Ein Eintrag, den Claude Code nicht als Anbieternamen erkennt, wird verworfen und gemeldet, und der Rest der Liste bleibt in Kraft. Bei einer leeren Liste oder einer Liste, deren Einträge allesamt nicht erkannt werden, lehnt Claude Code jeden Anbieter ab und startet auf dem Computer nicht.

#### Endpunkte, die eine Festlegung im verwalteten `env` benötigen

Eine Festlegung ist der Wert einer Endpunktvariable, der in einem verwalteten [`env`](#env)-Block gesetzt ist. Wenn eine Sitzung den Datenverkehr eines Anbieters an ein anderes Ziel als den eigenen Dienst dieses Anbieters sendet, lässt Claude Code dies nur zu, wenn der Wert der Sitzung mit der Festlegung übereinstimmt. Diese Endpunkte benötigen eine Festlegung:

* **`"customEndpoint"`-Sitzungen**: die Variable, die den Host angibt, etwa `ANTHROPIC_BASE_URL`
* **Amazon Bedrock**: die AWS SDK-Variablen `AWS_ENDPOINT_URL`, `AWS_ENDPOINT_URL_BEDROCK` und `AWS_ENDPOINT_URL_BEDROCK_RUNTIME`, wenn sie außerhalb des eigenen Dienstes von Bedrock zeigen. Die Sitzung bleibt unter `"bedrock"` statt `"customEndpoint"`
* **Die URL einer Gateway-Anmeldung**: Die Sitzung bleibt unter `"gateway"`, und [`forceLoginGatewayUrl`](#forcelogingatewayurl) zählt ebenfalls als Festlegung

Welche `env`-Blöcke als Festlegungen zählen, hängt davon ab, wo die Liste gesetzt ist:

* **Eine Administratorquelle auf dem Computer setzt eine Liste**: Nur die `env`-Blöcke der eigenen Administratorquellen des Computers zählen
* **Nur server-verwaltete Einstellungen setzen eine Liste**: Ein `env`-Wert in diesen server-verwalteten Einstellungen zählt ebenfalls

Die Liste bewertet weder die Anmeldedaten- und Mandantenvariablen eines Cloud-Anbieters noch den Netzwerkpfad, etwa `HTTPS_PROXY` und Zertifikatseinstellungen. Setzen Sie diese für die gesamte Flotte im verwalteten `env`-Block.

### `apiKeyHelper`

Führen Sie Ihren eigenen Befehl aus, um die Anmeldedaten zu generieren, die Claude Code mit Modellanfragen sendet. Claude Code führt den Befehl über die System-Shell aus, `/bin/sh` auf macOS und Linux und `cmd` auf Windows, und sendet seine Ausgabe als sowohl `X-Api-Key` als auch `Authorization: Bearer` Header. Verwenden Sie es für dynamische oder rotierende Anmeldedaten, wie kurzlebige Token, die aus einem Vault abgerufen werden.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: string, eine Shell-Befehlszeile
* **Standard**: nicht gesetzt, daher führt Claude Code keinen Helfer aus

```json settings.json theme={null}
{
  "apiKeyHelper": "/bin/generate_temp_api_key.sh"
}
```

Claude Code speichert den Wert zwischen und führt den Befehl in diesen Fällen erneut aus:

* Nach der Cache-Lebensdauer, standardmäßig fünf Minuten oder das Intervall, das Sie mit [`CLAUDE_CODE_API_KEY_HELPER_TTL_MS`](https://code.claude.com/docs/de/env-vars) festlegen.
* Wenn eine Anfrage an die Anthropic API, direkt oder über ein [LLM-Gateway](https://code.claude.com/docs/de/llm-gateway), mit `401` oder `403` fehlschlägt.
* Vor dem Senden einer Anfrage an die Anthropic API, direkt oder über ein LLM-Gateway, wenn die zwischengespeicherte Ausgabe ein JWT ist, das nach der Generierung durch den Helfer abgelaufen ist. Erfordert Claude Code v2.1.246 oder später.

Die letzten beiden Fälle gelten nur, wenn die Ausgabe des Helfers die Anmeldedaten sind, die Claude Code sendet, und `ANTHROPIC_AUTH_TOKEN` nicht gesetzt ist.

In interaktiven Sitzungen führt Claude Code den Befehl nicht aus, bis Sie die Abfrage zur Workspace-Vertrauenswürdigkeit akzeptieren, wenn der Befehl aus Projekt- oder lokalen Einstellungen stammt. Siehe [Verwaltung von Anmeldedaten](https://code.claude.com/docs/de/authentication.md#credential-management).

### `awsAuthRefresh`

Führen Sie Ihren eigenen Befehl aus, z. B. `aws sso login`, um die Anmeldedaten in Ihrem `.aws`-Verzeichnis zu aktualisieren, wenn die Anmeldedaten, die Claude Code für [Amazon Bedrock](https://code.claude.com/docs/de/amazon-bedrock.md) hat, nicht mehr funktionieren. Claude Code überprüft zunächst die aktuellen Anmeldedaten gegen STS und führt den Befehl nur aus, wenn diese Überprüfung fehlschlägt, und liest dann das aktualisierte `.aws`-Verzeichnis.

Wenn die Überprüfung gleichzeitig in mehreren Claude Code-Prozessen fehlschlägt, die denselben Befehl und dieselben Anmeldedaten verwenden, etwa in separaten Terminals oder IDE-Fenstern, führt ein Prozess den Befehl aus, und die übrigen warten auf diesen Lauf, statt einen eigenen zu starten. Ein Prozess, der mit einer ausstehenden Anfrage 60 Sekunden gewartet hat, führt den Befehl selbst aus. Um dies zu deaktivieren, setzen Sie [`CLAUDE_CODE_DISABLE_AUTH_REFRESH_LOCK`](https://code.claude.com/docs/de/env-vars) auf `1`.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: string, eine Shell-Befehlszeile
* **Standard**: nicht gesetzt, daher aktualisiert Claude Code AWS-Anmeldedaten nicht für Sie

```json settings.json theme={null}
{
  "awsAuthRefresh": "aws sso login --profile myprofile"
}
```

Verwenden Sie diesen Schlüssel, wenn Ihr Aktualisierungsablauf in `.aws` schreibt; verwenden Sie [`awsCredentialExport`](#awscredentialexport), wenn er stattdessen Anmeldedaten ausgibt. Siehe [erweiterte Anmeldedatenkonfiguration](https://code.claude.com/docs/de/amazon-bedrock.md#advanced-credential-configuration).

### `awsCredentialExport`

Führen Sie Ihren eigenen Befehl aus, der AWS-Anmeldedaten als JSON ausgibt, damit Claude Code [Amazon Bedrock](https://code.claude.com/docs/de/amazon-bedrock.md) mit Anmeldedaten aufrufen kann, die nicht in Ihrem `.aws`-Verzeichnis vorhanden sind. Claude Code akzeptiert die `aws sts` Ausgabeform und die flache `aws configure export-credentials` Form und beschränkt die Anmeldedaten auf seinen eigenen Bedrock-Client, sodass die Shell-Befehle, die Claude ausführt, immer noch Ihre Umgebungsanmeldedaten sehen.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: string, eine Shell-Befehlszeile
* **Standard**: nicht gesetzt, daher verwendet Claude Code die Umgebungs-AWS-Anmeldedatenkette

```json settings.json theme={null}
{
  "awsCredentialExport": "/bin/generate_aws_grant.sh"
}
```

Im Gegensatz zu [`awsAuthRefresh`](#awsauthrefresh) führt Claude Code diesen Befehl immer aus, wenn er gesetzt ist, ohne zunächst die Umgebungsanmeldedaten zu überprüfen. Siehe [erweiterte Anmeldedatenkonfiguration](https://code.claude.com/docs/de/amazon-bedrock.md#advanced-credential-configuration).

### `forceLoginMethod`

Beschränken Sie, mit welcher Art von Konto sich Personen anmelden können. Setzen Sie `"claudeai"`, um nur claude.ai-Konten zuzulassen, `"console"`, um nur Claude Console-Konten zuzulassen, oder `"gateway"`, um Personen zu einem [Cloud-Gateway](https://code.claude.com/docs/de/claude-apps-gateway) statt zu einer First-Party-Anmeldung zu senden. Administratoren legen es in verwalteten Einstellungen fest und koppeln es mit [`forceLoginOrgUUID`](#forceloginorguuid), um die claude.ai-Anmeldungen von Entwicklern in einer Organisation zu halten. Wenn Sie es in einer beliebigen Einstellungsdatei auf `"claudeai"` oder `"console"` setzen, stoppt Claude Code auch das Angebot der [schlüssellosen Console-Anmeldung](https://code.claude.com/docs/de/authentication.md#sign-in-without-an-api-key) in den Sitzungen, auf die diese Datei zutrifft.

* **Geltungsbereich**: [`Any file`](#scopes). Claude Code berücksichtigt `"gateway"` aus denselben Quellen wie [`forceLoginGatewayUrl`](#forcelogingatewayurl) und behandelt es überall sonst als nicht gesetzt.
* **Typ**: string, einer von:
  * `"claudeai"`: nur claude.ai-Konten können sich anmelden
  * `"console"`: nur Claude Console-Konten können sich anmelden
  * `"gateway"`: Claude Code sendet Personen zu einem Cloud-Gateway statt zu einer First-Party-Anmeldung
* **Standard**: nicht gesetzt, daher wählen Personen eine Anmeldemethode

```json settings.json theme={null}
{
  "forceLoginMethod": "claudeai"
}
```

Jeder First-Party-Anmeldepfad wendet die Einschränkung an, einschließlich der [VS Code-Erweiterung](https://code.claude.com/docs/de/vs-code.md), des Agent SDK, `claude setup-token` und `/install-github-app`, mit Ausnahme des interaktiven Anmeldebildschirms des Terminals, der über `/login` oder das Onboarding beim ersten Start erreichbar ist, das die Methode vorwählt, ohne sie zu erzwingen. Vor v2.1.212 galt dies nur für Terminal-Anmeldungen. Siehe [Anmeldung auf Ihre Organisation beschränken](https://code.claude.com/docs/de/authentication.md#restrict-login-to-your-organization), um zu erfahren, wie jeder Anmeldepfad, Umgebungsanmeldedaten und Drittanbieter behandelt werden.

Wenn eine verwaltete Quelle auf dem Computer `"gateway"` setzt, verwendet Claude Code keine verbleibende Anmeldung, keinen API-Schlüssel oder `apiKeyHelper`-Anmeldedaten. Siehe [Administrator-Richtlinie erfordert eine Cloud-Gateway-Anmeldung](https://code.claude.com/docs/de/errors.md#administrator-policy-requires-a-cloud-gateway-sign-in) für die Nachricht, die jede erzeugt. Wenn Sie einen Cloud-Anbieter über `CLAUDE_CODE_USE_BEDROCK` oder eine ähnliche Umgebungsvariable auswählen, benötigt die Sitzung keine Gateway-Anmeldung. Vor v2.1.261 verwendete Claude Code eine verbleibende Anmeldung auf diesen Computern.

### `forceLoginGatewayUrl`

Legen Sie die Gateway-URL fest, mit der sich der `/login` Cloud-Gateway-Bildschirm verbindet, damit Personen Ihr [Cloud-Gateway](https://code.claude.com/docs/de/claude-apps-gateway) erreichen, ohne seine Adresse einzugeben. Der Bildschirm hat kein URL-Feld: Mit diesem Schlüssel gesetzt zeigt er Ihre Gateway-URL an und verbindet sich, wenn die Person die Eingabetaste drückt; ohne ihn teilt er ihnen mit, sich an ihren IT-Administrator zu wenden.

In verwalteten Einstellungen macht entweder dieser Schlüssel oder `forceLoginMethod: "gateway"` den Computer zu einem reinen Gateway-Computer, mit Ausnahme von Sitzungen, die einen Cloud-Anbieter mit `CLAUDE_CODE_USE_*` auswählen. `/login` öffnet dann auf dem Cloud-Gateway-Bildschirm ohne Anmeldemethoden-Picker. Siehe [Administrator-Richtlinie erfordert eine Cloud-Gateway-Anmeldung](https://code.claude.com/docs/de/errors.md#administrator-policy-requires-a-cloud-gateway-sign-in), um zu erfahren, was mit einer verbleibenden First-Party-Anmeldung oder einem API-Schlüssel geschieht. Legen Sie beide Schlüssel fest, damit sich der Bildschirm verbindet, statt einen Fehler anzuzeigen.

* **Geltungsbereich**: [`User or managed`](#scopes). Wird von einer verwalteten Quelle auf dem Computer gelesen: `managed-settings.json`, die macOS plist oder Windows HKLM-Registrierung oder ein Policy-Helfer. Auf einem Computer ohne eine dieser Quellen liest Claude Code v2.1.295 oder später es auch aus den [Benutzereinstellungen](https://code.claude.com/docs/de/claude-apps-gateway#set-the-gateway-url-in-user-settings). Claude Code ignoriert es in HKCU- und Server-verwalteten Einstellungen.
* **Typ**: string, eine vollständige URL einschließlich des Schemas
* **Standard**: nicht gesetzt, daher zeigt der Cloud-Gateway-Bildschirm einen Fehler an, der Personen auffordert, sich an ihren IT-Administrator zu wenden

```json managed-settings.json theme={null}
{
  "forceLoginGatewayUrl": "https://claude-gateway.example.com"
}
```

Wenn der Wert keine gültige URL ist, meldet der Anmeldebildschirm dies, und der Rest der verwalteten Einstellungsdatei wird immer noch angewendet. Siehe [Gateway-URL festlegen](https://code.claude.com/docs/de/claude-apps-gateway#set-the-gateway-url).

### `forceLoginOrgUUID`

Verlangen Sie von einer verwalteten Quelle, dass claude.ai-Kontoanmeldungen zu einer Anthropic-Organisation gehören, angegeben als eine einzelne UUID, oder zu einer von mehreren Organisationen, angegeben als Array. Aus einer beliebigen Einstellungsdatei verwendet Claude Code auch eine einzelne UUID, um diese Organisation während einer claude.ai- oder Claude Console-Anmeldung vorzuwählen, und wählt nichts für ein Array vor. Wenn Sie den Schlüssel in einer beliebigen Einstellungsdatei setzen, stoppt Claude Code auch das Angebot der [schlüssellosen Console-Anmeldung](https://code.claude.com/docs/de/authentication.md#sign-in-without-an-api-key) in den Sitzungen, auf die diese Datei zutrifft, und erstellt stattdessen einen API-Schlüssel.

* **Geltungsbereich**: [`Any file`](#scopes). Nur eine verwaltete Quelle erzwingt die Einschränkung; eine einzelne UUID in einer beliebigen anderen Einstellungsdatei wählt die Organisation während der Anmeldung vor, ohne sie einzuschränken.
* **Typ**: string, eine UUID, oder Array von Strings, mehrere UUIDs
* **Standard**: nicht gesetzt, daher kann sich jede Organisation anmelden

Dieses Beispiel akzeptiert Anmeldungen von einer von zwei Organisationen, ohne eine vorzuwählen:

```json managed-settings.json theme={null}
{
  "forceLoginOrgUUID": ["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]
}
```

Wenn eine verwaltete Quelle ein leeres Array setzt oder einen Wert, der weder ein String noch ein Array von Strings ist, können Benutzer, die sich mit einem Anthropic-Konto anmelden, Claude Code nicht starten und keine Anmeldung abschließen. Sie sehen eine Meldung, die `forceLoginOrgUUID` nennt und sie auffordert, sich an ihren Administrator zu wenden. Ein [`policyHelper`](#policyhelper), der einen Wert des falschen Typs ausgibt, [schlägt bei seinem Lauf fehl](#helper-failures) statt dessen.

Siehe [Anmeldung auf Ihre Organisation beschränken](https://code.claude.com/docs/de/authentication.md#restrict-login-to-your-organization), um zu erfahren, wie Claude Code Claude Console-Anmeldungen, die anderen Anmeldepfade und Umgebungsanmeldedaten behandelt.

### `gatewayInternalNetworks`

Deklarieren Sie die öffentlichen IPv4-Blöcke, aus denen Ihre Organisation ihr internes Netzwerk nummeriert, damit `/login` ein [Cloud-Gateway](https://code.claude.com/docs/de/claude-apps-gateway) dort akzeptiert. Erfordert Claude Code v2.1.268 oder später.

Ohne diesen Schlüssel verbindet sich `/login` mit jedem Gateway auf einer privaten Adresse und nichts anderem. Mit ihm akzeptiert `/login` auch ein Gateway innerhalb eines aufgelisteten Blocks, nur über eine direkte Verbindung. Die eigene Adresse des Computers auf dieser Verbindung muss sich auch innerhalb desselben Blocks befinden.

* **Geltungsbereich**: [`Managed`](#scopes). Wird nur von einer Quelle auf dem Computer gelesen: `managed-settings.json`, die macOS plist oder Windows HKLM-Registrierung oder ein Policy-Helfer. Claude Code ignoriert es in HKCU- und Server-verwalteten Einstellungen.
* **Typ**: Array von Strings, höchstens vier IPv4-CIDR-Blöcke, jeweils `/8` bis `/32`, nicht überlappend miteinander und keine Überlappung mit privatem Raum.
* **Standard**: nicht gesetzt, daher akzeptiert `/login` nur Gateways auf privaten Adressen

```json managed-settings.json theme={null}
{
  "gatewayInternalNetworks": ["203.0.113.0/24"]
}
```

Ersetzen Sie den Dokumentationsbereich im Beispiel durch Ihren eigenen Block. Claude Code lehnt die Dokumentationsbereiche, die Bereiche, die VPN- und NAT64-Clients lokal verwenden, und reservierten Raum ab, aus dem kein Netzwerk nummeriert wird, wie Multicast.

Wenn ein Eintrag ungültig ist oder der Wert keine Liste von Strings ist, benennt `/login` das Problem und lehnt jede neue Gateway-Anmeldung auf dem Computer ab, bis Sie den Wert korrigieren. Bestehende Anmeldungen funktionieren weiterhin. Siehe [Erlauben Sie ein Gateway auf öffentlichem Adressraum, den Sie besitzen](https://code.claude.com/docs/de/claude-apps-gateway#allow-a-gateway-on-public-address-space-you-own) für die vollständigen Regeln und was Entwickler sehen.

### `gcpAuthRefresh`

Führen Sie Ihren eigenen Befehl aus, um Google Cloud Application Default Credentials zu aktualisieren, wenn Claude Code feststellt, dass sie abgelaufen sind oder nicht geladen werden können, damit Anfragen an [Google Cloud's Agent Platform](https://code.claude.com/docs/de/google-vertex-ai.md) weiterhin funktionieren, ohne dass Sie sich manuell erneut authentifizieren müssen.

Wenn mehrere Claude Code-Prozesse, die denselben Befehl und dieselben Anmeldedaten verwenden, etwa in separaten Terminals oder IDE-Fenstern, gleichzeitig feststellen, dass diese abgelaufen sind, führt ein Prozess den Befehl aus, und die übrigen warten auf diesen Lauf, statt einen eigenen zu starten. Ein Prozess, der mit einer ausstehenden Anfrage 60 Sekunden gewartet hat, führt den Befehl selbst aus. Um dies zu deaktivieren, setzen Sie [`CLAUDE_CODE_DISABLE_AUTH_REFRESH_LOCK`](https://code.claude.com/docs/de/env-vars) auf `1`.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: string, eine Shell-Befehlszeile
* **Standard**: nicht gesetzt, daher teilt Ihnen der Anmeldedatenfehler von Claude Code mit, `gcloud auth application-default login` selbst auszuführen

```json settings.json theme={null}
{
  "gcpAuthRefresh": "gcloud auth application-default login"
}
```

Siehe [erweiterte Anmeldedatenkonfiguration](https://code.claude.com/docs/de/google-vertex-ai.md#advanced-credential-configuration).

### `otelHeadersHelper`

Führen Sie Ihren eigenen Befehl aus, um die Header zu generieren, die Claude Code mit OpenTelemetry-Exporten sendet, für Backends, deren Token rotieren. Claude Code führt ihn beim Start und danach regelmäßig aus und erwartet ein JSON-Objekt von String-Header-Werten auf stdout.

* **Geltungsbereich**: [`Any file`](#scopes)
* **Typ**: string, ein ausführbarer Pfad oder eine Shell-Befehlszeile
* **Standard**: nicht gesetzt, daher fügt Claude Code keine Helfer-generierten Header hinzu

```json settings.json theme={null}
{
  "otelHeadersHelper": "/bin/generate_otel_headers.sh"
}
```

Legen Sie das Aktualisierungsintervall mit [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](https://code.claude.com/docs/de/env-vars) fest. Siehe [Dynamische Header](https://code.claude.com/docs/de/monitoring-usage.md#dynamic-headers) für die Skriptanforderungen und was passiert, wenn der Helfer fehlschlägt.

## Aktualisierungen und Versionsverwaltung

Wählen Sie einen Aktualisierungskanal und fixieren Sie für Organisationen die Versionen, die Personen ausführen können. Siehe [Claude Code aktualisieren](https://code.claude.com/docs/de/setup.md#update-claude-code).

### `autoUpdatesChannel`

Wählen Sie, welcher [Release-Kanal](https://code.claude.com/docs/de/setup.md#configure-release-channel) Hintergrund-Autoupdates und `claude update` folgen. Setzen Sie `"stable"` für eine Version, die typischerweise etwa eine Woche alt ist und Releases mit großen Regressionen überspringt, oder `"latest"` für die neueste Version.

* **Bereich**: [`Any file`](#scopes). Legen Sie es in verwalteten Einstellungen fest, um einen Kanal in Ihrer gesamten Organisation durchzusetzen.
* **Typ**: string, einer von:
  * `"latest"`: Aktualisierungen folgen der neuesten Version
  * `"stable"`: Aktualisierungen folgen einer Version, die typischerweise etwa eine Woche alt ist und Releases mit großen Regressionen überspringt
* **Standard**: nicht gesetzt, daher folgt Claude Code `"latest"`

```json settings.json theme={null}
{
  "autoUpdatesChannel": "stable"
}
```

Claude Code schreibt `"stable"` in Ihre Benutzereinstellungen, wenn Sie es unter **Auto-update channel** in `/config` auswählen, und entfernt den Schlüssel, wenn Sie dort zurück zu latest wechseln. `claude install stable` und `claude install latest` speichern auch den Kanal, den Sie benennen. Das Wechseln von `"latest"` zu `"stable"` in `/config` fragt, ob ein Downgrade erlaubt sein soll oder ob Sie bei Ihrer aktuellen Version bleiben möchten; das Bleiben setzt [`minimumVersion`](#minimumversion). Homebrew-Installationen ignorieren diesen Schlüssel: das `claude-code` Cask verfolgt stable und `claude-code@latest` verfolgt latest, und `claude update` delegiert an `brew upgrade`. Um Autoupdates vollständig auszuschalten, setzen Sie [`DISABLE_AUTOUPDATER`](https://code.claude.com/docs/de/setup#disable-auto-updates) in `env`.

### `minimumVersion`

Verhindern Sie, dass Hintergrund-Autoupdates und `claude update` eine Version unterhalb dieser installieren, damit ein Wechsel zum `"stable"` Kanal Sie nicht von einem neueren `"latest"` Build herabstuft. Claude Code schreibt diesen Schlüssel für Sie, wenn Sie sich entscheiden, bei Ihrer aktuellen Version zu bleiben, während Sie Kanäle in `/config` wechseln, und löscht ihn, wenn Sie zurück zu `"latest"` wechseln.

* **Bereich**: [`Any file`](#scopes). Legen Sie es in verwalteten Einstellungen fest, um ein organisationsweites Minimum zu fixieren, das Benutzer- und Projekteinstellungen nicht senken können.
* **Typ**: string, eine Versionsnummer wie `"2.1.100"`; ein Wert, der keine gültige Version ist, wird ignoriert
* **Standard**: nicht gesetzt, daher können Aktualisierungen jede Version installieren, die der Kanal anbietet

Dieses Beispiel folgt dem stabilen Kanal und weigert sich, eine Version unterhalb von 2.1.100 zu installieren:

```json settings.json theme={null}
{
  "autoUpdatesChannel": "stable",
  "minimumVersion": "2.1.100"
}
```

Dieser Schlüssel beschränkt nur Aktualisierungen. Um Claude Code zu veranlassen, unterhalb einer Version nicht zu starten, verwenden Sie stattdessen [`requiredMinimumVersion`](#requiredminimumversion). Siehe [Minimum-Version fixieren](https://code.claude.com/docs/de/setup.md#pin-a-minimum-version).

### `requiredMaximumVersion`

Legen Sie die neueste Claude Code-Version fest, die Ihre Organisation starten darf. Wenn die laufende Version neuer ist, beendet Claude Code sich beim Start und teilt dem Benutzer mit, eine genehmigte Version durch die genehmigte Methode Ihrer Organisation zu installieren; `claude install <version>` kann auch funktionieren. Erfordert Claude Code v2.1.163 oder später.

* **Bereich**: [`Managed`](#scopes). Claude Code gibt keine Warnung aus, wenn es den Schlüssel anderswo ignoriert.
* **Typ**: string, eine Versionsnummer wie `"2.1.150"`; ein Wert, der keine gültige Version ist, wird ignoriert
* **Standard**: nicht gesetzt, daher gilt keine Obergrenze

```json managed-settings.json theme={null}
{
  "requiredMaximumVersion": "2.1.150"
}
```

Hintergrund-Autoupdates und `claude update` überspringen Versionen über der Obergrenze, daher bleibt eine Installation innerhalb des Bereichs darin. `claude update`, `claude install` und `claude doctor` funktionieren weiterhin über der Obergrenze, damit Benutzer sich wiederherstellen können. Kombinieren Sie es mit [`requiredMinimumVersion`](#requiredminimumversion), um einen Bereich durchzusetzen.

### `requiredMinimumVersion`

Legen Sie die älteste Claude Code-Version fest, die Ihre Organisation starten darf. Wenn die laufende Version älter ist, beendet Claude Code sich beim Start und teilt dem Benutzer mit, ein Update durch die genehmigte Methode Ihrer Organisation durchzuführen. Die Überprüfung läuft nur beim Start, daher wird eine bereits laufende Sitzung fortgesetzt. Erfordert Claude Code v2.1.163 oder später.

* **Bereich**: [`Managed`](#scopes). Claude Code gibt keine Warnung aus, wenn es den Schlüssel anderswo ignoriert.
* **Typ**: string, eine Versionsnummer wie `"2.1.150"`; ein Wert, der keine gültige Version ist, wird ignoriert
* **Standard**: nicht gesetzt, daher gilt keine Untergrenze

```json managed-settings.json theme={null}
{
  "requiredMinimumVersion": "2.1.150"
}
```

`claude update`, `claude install` und `claude doctor` funktionieren weiterhin unter der Untergrenze, damit Benutzer sich wiederherstellen können. Im Gegensatz zu [`minimumVersion`](#minimumversion), das nur Downgrades verhindert, blockiert dieser Schlüssel den Start. Kombinieren Sie es mit [`requiredMaximumVersion`](#requiredmaximumversion), um einen Bereich durchzusetzen.

## Werkzeuge

Deaktivieren Sie spezifische Werkzeuge in der [Claude Code Desktop-App](https://code.claude.com/docs/de/desktop.md). Die Terminal-CLI ignoriert diese Schlüssel. Für die Werkzeuge selbst siehe [Werkzeuge, die Claude zur Verfügung stehen](https://code.claude.com/docs/de/tools-reference.md).

### `browserExternalPageTools`

Verhindern Sie, dass Claude seine Werkzeuge zum Lesen oder Bearbeiten externer Seiten im [Browser-Bereich](https://code.claude.com/docs/de/desktop.md#browse-external-sites) der Desktop-App verwendet. Personen in Ihrer Organisation können externe Websites weiterhin selbst öffnen, und lokale Dev-Server-Vorschauversionen funktionieren weiterhin mit Claudes Werkzeugen. Die Desktop-App liest diesen Schlüssel; die Terminal-CLI ignoriert ihn.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: String, `"disabled"`; die Desktop-App akzeptiert auch `"disable"`, in beiden Fällen
* **Standard**: nicht gesetzt, daher funktionieren Claudes Werkzeuge auf externen Seiten

```json managed-settings.json theme={null}
{
  "browserExternalPageTools": "disabled"
}
```

Jeder andere Wert lässt Claudes Werkzeuge eingeschaltet, und ein nicht leerer String, der nicht einer der beiden akzeptierten Werte ist, protokolliert eine Warnung. Um externe Websites für Personen und Claude gleichermaßen zu blockieren, setzen Sie stattdessen [`disableBrowserExternalNavigation`](#disablebrowserexternalnavigation). Siehe [Externe Browsing für Ihre Organisation einschränken](https://code.claude.com/docs/de/desktop.md#restrict-external-browsing-for-your-organization).

### `disableBrowserExternalNavigation`

Deaktivieren Sie das externe Browsing im [Browser-Bereich](https://code.claude.com/docs/de/desktop.md#browse-external-sites) der Desktop-App für Personen und Claude gleichermaßen. Localhost Dev-Server-Vorschauversionen funktionieren weiterhin. Die Desktop-App liest diesen Schlüssel; die Terminal-CLI ignoriert ihn.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Boolean; nur der JSON-Boolean `true` hat Auswirkungen
  * `true`: die Desktop-App deaktiviert das externe Browsing im Browser-Bereich für Personen und Claude gleichermaßen; Localhost-Vorschauversionen funktionieren weiterhin
  * `false`: das externe Browsing bleibt aktiviert
* **Standard**: nicht gesetzt, daher ist das externe Browsing aktiviert

```json managed-settings.json theme={null}
{
  "disableBrowserExternalNavigation": true
}
```

Die Desktop-App ignoriert jeden anderen Wert, und ein Wert, der kein Boolean ist, wie der String `"true"` oder `1`, protokolliert auch eine Warnung. Um das externe Browsing aktiviert zu lassen, aber Claudes Werkzeuge auf externen Seiten deaktiviert zu halten, setzen Sie stattdessen [`browserExternalPageTools`](#browserexternalpagetools). Siehe [Externe Browsing für Ihre Organisation einschränken](https://code.claude.com/docs/de/desktop.md#restrict-external-browsing-for-your-organization).

### `disableMobileSimulatorTools`

Blockieren Sie Claudes Werkzeuge für den [iOS Simulator-Bereich](https://code.claude.com/docs/de/desktop-ios-simulator.md#turn-off-simulator-access) der Desktop-App. Personen behalten die manuelle Nutzung des Bereichs; nur Claudes Zugriff wird entfernt, und niemand kann ihn von innerhalb der App wieder aktivieren. Die Desktop-App liest diesen Schlüssel; die Terminal-CLI ignoriert ihn.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Boolean; nur der JSON-Boolean `true` hat Auswirkungen
  * `true`: die Desktop-App blockiert Claudes Werkzeuge für den iOS Simulator-Bereich
  * `false`: Claudes Simulator-Werkzeuge folgen der Einstellung jeder Person in der Desktop-App
* **Standard**: nicht gesetzt, daher folgen Claudes Simulator-Werkzeuge der Einstellung jeder Person in der Desktop-App

```json managed-settings.json theme={null}
{
  "disableMobileSimulatorTools": true
}
```

Die Desktop-App ignoriert jeden anderen Wert, und ein Wert, der kein Boolean ist, wie der String `"true"` oder `1`, protokolliert auch eine Warnung.

## Datenschutz und Telemetrie

Steuern Sie, wie lange Claude Code Sitzungsdaten speichert und was es sendet. Die Schalter zum Deaktivieren von Nutzungsmetriken und Fehlerberichten sind Umgebungsvariablen, keine Einstellungsschlüssel: Setzen Sie `DISABLE_TELEMETRY`, `DISABLE_ERROR_REPORTING` oder `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` im Schlüssel [`env`](#env) oder in der Shell. [Telemetrie-Dienste](https://code.claude.com/docs/de/data-usage.md#telemetry-services) zeigt, was jeder stoppt. Zwei Ausnahmen werden aus einer Einstellungsdatei deaktiviert: [`feedbackDrafts`](#feedbackdrafts) unten für von Claude entworfenes Feedback und [`feedbackSurveyRate`](#feedbacksurveyrate) unten für die Sitzungsumfrage.

### `cleanupPeriodDays`

Legen Sie fest, wie viele Tage Claude Code [Sitzungstranskripte und andere Anwendungsdaten](https://code.claude.com/docs/de/claude-directory.md#cleaned-up-automatically) speichert, bevor sie gelöscht werden. Claude Code führt die Löschung als Hintergrund-Sweep nach dem Start einer Sitzung durch, solange es die Aufbewahrungsfrist sicher bestimmen kann. Der Sweep löscht Transkripte, ohne eine Meldung anzuzeigen, sodass eine Sitzung, die Sie länger als die Aufbewahrungsfrist nicht verwendet haben, nicht mehr in der [`/resume`](https://code.claude.com/docs/de/sessions#resume-a-session)-Auswahl erscheint.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Anzahl der Tage, eine ganze Zahl, Minimum `1`
* **Standard**: `30`

```json settings.json theme={null}
{
  "cleanupPeriodDays": 20
}
```

Das Setzen von `0` schlägt bei der Validierung fehl, wählen Sie daher einen großen Wert wie `3650` für lange Aufbewahrung. Um Claude Code davon abzuhalten, Transkripte überhaupt zu schreiben, siehe [Plaintext-Speicherung](https://code.claude.com/docs/de/claude-directory.md#plaintext-storage).

### `desktopSessionCleanupPeriodDays`

Legen Sie eine Altersgrenze in Tagen für die Transkripte von Sitzungen fest, die Sie in Claude Desktop oder Cowork gestartet oder zuletzt fortgesetzt haben. Ohne diesen Schlüssel [behält Claude Code diese Transkripte in jedem Alter](https://code.claude.com/docs/de/claude-directory.md#cleaned-up-automatically). Claude Code löscht jedes, sobald es älter ist als sowohl diese Grenze als auch [`cleanupPeriodDays`](#cleanupperioddays), also mit `cleanupPeriodDays` auf dem Standard von 30 behält ein Wert von `7` sie immer noch 30 Tage. [Automatisch bereinigt](https://code.claude.com/docs/de/claude-directory.md#cleaned-up-automatically) listet die Fälle auf, in denen stattdessen `cleanupPeriodDays` gilt und Claude Code diesen Schlüssel ignoriert. Erfordert Claude Code v2.1.248 oder später.

* **Bereich**: [`User or managed`](#scopes). Claude Code liest den Schlüssel auch aus einer Datei, die Sie mit `--settings` übergeben, und ignoriert ihn in Projekt- und lokalen Einstellungen.
* **Typ**: Anzahl der Tage, eine ganze Zahl, Minimum `0`
* **Standard**: `0`, was keine Altersgrenze setzt

```json settings.json theme={null}
{
  "desktopSessionCleanupPeriodDays": 90
}
```

### `feedbackDrafts`

Steuern Sie [von Claude entworfenes Feedback](https://code.claude.com/docs/de/tools-reference.md#sendfeedback-tool-behavior): ob Claude Feedback-Entwürfe zur Überprüfung in die Warteschlange einreihen kann und ob Claude Code eine Karte anzeigt, wenn Claude einen einreiht.

* **Bereich**: [`User or managed`](#scopes)
* **Typ**: String, einer von `"notify"`, `"quiet"` oder `"off"`
  * `"notify"`: Claude Code zeigt eine Karte über der Eingabeaufforderung an, wenn Claude einen Entwurf einreiht, standardmäßig bis zu [drei Karten in einer Sitzung](https://code.claude.com/docs/de/tools-reference.md#what-you-see-when-claude-drafts)
  * `"quiet"`: Claude entwirft ohne Karte. Sie sehen die Anzahl der eingereihten Entwürfe in der Eingabeaufforderungs-Fußzeile und überprüfen sie in `/feedback`
  * `"off"`: Claude Code entfernt das SendFeedback-Tool, sodass Claude keine Entwürfe einreihen kann
* **Standard**: `"notify"`
* **Sitzungsspezifische Überschreibungen**: [`CLAUDE_CODE_SEND_FEEDBACK`](https://code.claude.com/docs/de/env-vars) auf `0` gesetzt deaktiviert die Funktion für eine Sitzung

```json settings.json theme={null}
{
  "feedbackDrafts": "quiet"
}
```

Erscheint in `/config` als **Claude-drafted feedback**, das diesen Schlüssel in Ihre Benutzereinstellungen schreibt. Sie sehen die `/config`-Zeile nur in Sitzungen, [in denen Claude Feedback entwerfen kann](https://code.claude.com/docs/de/tools-reference.md#sessions-without-claude-drafted-feedback); das Setzen von `"off"` blendet sie nicht aus, sodass Sie die Funktion aus derselben Zeile wieder aktivieren können. Ein Wert in verwalteten Einstellungen hat Vorrang vor Ihrer Benutzereinstellung, sodass wenn ein Administrator diesen Schlüssel setzt, die Zeile den verwalteten Wert anzeigt und das Ändern hat keine Auswirkung. Claude Code ignoriert diesen Schlüssel in Projekt- und lokalen Einstellungen.

### `feedbackSurveyRate`

Legen Sie die Wahrscheinlichkeit fest, dass die [Sitzungsqualitätsumfrage](https://code.claude.com/docs/de/data-usage.md#session-quality-surveys) angezeigt wird, wenn eine Sitzung für sie berechtigt ist. Setzen Sie `0`, um zu verhindern, dass die Umfrage angezeigt wird.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Zahl zwischen `0` und `1`
* **Standard**: nicht gesetzt, sodass Claude Code die Rate verwendet, die Anthropic remote setzt, oder seine integrierte Rate von `0.005` auf Amazon Bedrock, Google Cloud's Agent Platform und Microsoft Foundry, die keine Remote-Konfiguration erhalten
* **Sitzungsspezifische Überschreibungen**: [`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY`](https://code.claude.com/docs/de/env-vars) auf `1` gesetzt deaktiviert die Umfrage für eine Sitzung, unabhängig davon, welche Rate dieser Schlüssel setzt

```json settings.json theme={null}
{
  "feedbackSurveyRate": 0.05
}
```

Die gleiche Rate gilt für die Umfrage in der VS Code-Erweiterung.

### `skipWebFetchPreflight`

Überspringen Sie die [WebFetch-Domänensicherheitsprüfung](https://code.claude.com/docs/de/data-usage.md#webfetch-domain-safety-check), die jeden angeforderten Hostnamen an `api.anthropic.com` sendet, bevor sie abruft. Setzen Sie `true` in Umgebungen, die den Datenverkehr zu Anthropic blockieren, wie z. B. Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry-Bereitstellungen mit restriktivem Ausgang.

* **Bereich**: [`Any file`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code überspringt die WebFetch-Domänensicherheitsprüfung
  * `false`: Die Prüfung wird vor dem ersten Abruf zu jedem Hostnamen in einer Sitzung ausgeführt und erneut für einen Hostnamen, dessen frühere Prüfung blockiert oder fehlgeschlagen ist
* **Standard**: nicht gesetzt, sodass die Prüfung vor dem ersten Abruf zu jedem Hostnamen in einer Sitzung ausgeführt wird

```json settings.json theme={null}
{
  "skipWebFetchPreflight": true
}
```

Mit der übersprungenen Prüfung versucht WebFetch jede URL, ohne die Blockliste zu konsultieren, also kombinieren Sie sie mit [`WebFetch`-Berechtigungsregeln](https://code.claude.com/docs/de/permissions#webfetch), wenn Sie einschränken müssen, welche Domänen Claude erreichen kann.

## Enterprise- und verwaltete Einstellungen

Schlüssel, die eine Organisation verwendet, um verwaltete Einstellungen zu berechnen, zu aktualisieren und zu kombinieren. Siehe [Verwaltete Einstellungen einrichten](https://code.claude.com/docs/de/admin-setup.md).

### `disableSideloadFlags`

Lehnen Sie die CLI-Flags `--plugin-dir`, `--plugin-url`, `--agents` und `--mcp-config` beim Start ab, die Benutzer andernfalls übergeben könnten, um [`strictKnownMarketplaces`](#strictknownmarketplaces) für einen einzelnen Durchlauf zu umgehen. Claude Code wird mit einem Fehler beendet, der die abgelehnten Flags benennt. In [Cloud-Sitzungen](https://code.claude.com/docs/de/claude-code-on-the-web.md) startet Claude Code stattdessen die Sitzung und verwirft jeden vom Server bereitgestellten `--mcp-config`-Eintrag mit Ausnahme von In-Process-Einträgen vom Typ `type: "sdk"` und der Slack-Tools einer [Claude Tag](https://code.claude.com/docs/de/claude-tag.md)-Sitzung. Erfordert Claude Code v2.1.193 oder später.

* **Bereich**: [`Managed`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code lehnt `--plugin-dir`, `--plugin-url`, `--agents` und `--mcp-config` beim Start ab und wird mit einem Fehler beendet, der diese benennt. In Cloud-Sitzungen startet es stattdessen die Sitzung und verwirft jeden vom Server bereitgestellten `--mcp-config`-Eintrag mit Ausnahme von In-Process-Einträgen vom Typ `type: "sdk"` und der Slack-Tools einer Claude Tag-Sitzung
  * `false`: Claude Code akzeptiert diese Flags
* **Standard**: `false`

```json managed-settings.json theme={null}
{
  "disableSideloadFlags": true
}
```

Claude Code akzeptiert weiterhin ein `--mcp-config`, dessen Server alle In-Process-Einträge vom Typ `type: "sdk"` sind, sodass das Agent SDK und die VS Code-Erweiterung weiterhin funktionieren. Benutzer können weiterhin Server mit `claude mcp add` oder einer `.mcp.json`-Datei hinzufügen; für Pro-Server-Kontrolle setzen Sie auch [`allowedMcpServers`](https://code.claude.com/docs/de/managed-mcp). Erfordert Claude Code v2.1.193 oder später.

Die gleiche Überprüfung deckt Plugin-Ordner ab, die in der Umgebungsvariablen [`CLAUDE_CODE_PLUGIN_DIRS`](https://code.claude.com/docs/de/env-vars#variables) benannt sind, was Claude Code v2.1.280 oder später erfordert. Wenn die Variable einen Ordner benennt, wird Claude Code mit dem gleichen Fehler beendet, und der Fehler sagt, die Variable zu deaktivieren.

In Cloud-Sitzungen ignoriert Claude Code auch vom Server bereitgestellte MCP-Updates während der Sitzung, den Pfad hinter der Cloud-Sitzungskonfiguration und SDK `setMcpServers()`-Aufrufe, die diese Sitzungen erreichen. In-Process-Einträge vom Typ `type: "sdk"` und die Slack-Tools einer Claude Tag-Sitzung bleiben dort ebenfalls ausgenommen. Vor v2.1.268 entfernten sowohl dieses Verwerfen als auch das Verwerfen beim Start auch die Slack-Tools einer Claude Tag-Sitzung. Vor v2.1.239 blockierte ein vom Server bereitgestelltes `--mcp-config` den Start einer Cloud-Sitzung.

Die Desktop-App verwaltet einige Plugins selbst, darunter von claude.ai synchronisierte Plugins und Plugins, die Ihre Organisation über die App bereitstellt. Wenn Sie diesen Schlüssel über MDM, eine Richtlinie auf Betriebssystemebene oder eine verwaltete Einstellungsdatei auf einem Gerät bereitstellen, übergibt die Desktop-App diese Plugins nicht an die folgenden Sitzungen auf diesem Gerät:

* **[Code-Sitzungen auf dem Computer des Benutzers](https://code.claude.com/docs/de/desktop.md#environment-configuration)**: Sie starten außerdem ohne die Skills, die für das claude.ai-Konto des Benutzers aktiviert sind. Plugins, die Claude Code aus Marketplaces in Ihren verwalteten Einstellungen installiert, werden weiterhin geladen. In [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview) bleiben auch MCP-Server aus Plugins verfügbar, die Sie im `org-plugins`-Verzeichnis des Geräts bereitstellen, da die Desktop-App selbst eine Verbindung zu ihnen herstellt. Vor Claude Desktop v1.37937.0 schlugen diese Sitzungen stattdessen beim Start fehl.
* **[Cowork-Sitzungen auf dem Computer des Benutzers](https://code.claude.com/docs/de/managed-settings.md#where-and-when-a-policy-applies)**: Die Skills in diesen Plugins und die für das claude.ai-Konto des Benutzers aktivierten Skills bleiben verfügbar. In [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview) bleiben auch MCP-Server aus Plugins verfügbar, die Sie im `org-plugins`-Verzeichnis des Geräts bereitstellen, da die Desktop-App selbst eine Verbindung zu ihnen herstellt. Vor Claude Desktop v1.44121.0 schlugen diese Sitzungen stattdessen beim Start fehl.

### `forceRemoteSettingsRefresh`

Blockieren Sie den CLI-Start, bis Claude Code [vom Server verwaltete Einstellungen](https://code.claude.com/docs/de/server-managed-settings.md) neu abgerufen hat. Wenn der Abruf fehlschlägt, wird Claude Code beendet, anstatt mit zwischengespeicherten oder ohne Einstellungen fortzufahren. Setzen Sie dies, wenn Ihre Umgebung nicht einmal ein kurzes Fenster akzeptieren kann, in dem eine Sitzung ohne ihre verwaltete Richtlinie ausgeführt wird.

Wenn der Schlüssel nicht gesetzt ist, blockiert Claude Code den Start nicht beim Abruf, obwohl es beim Anmelden des Entwicklers beim Start bis zu fünf Sekunden auf den Abruf wartet. Eine Cloud-Gateway-Sitzung wartet immer und wird beendet, wenn das Gateway nicht erreichbar ist.

* **Bereich**: [`Managed`](#scopes). Claude Code berücksichtigt ein `true` aus jeder admin-kontrollierten verwalteten Quelle, auch wenn es nicht die höchste Prioritätsquelle ist.
* **Typ**: Boolean
  * `true`: Claude Code blockiert den Start, bis er vom Server verwaltete Einstellungen neu abgerufen hat, und wird beendet, wenn der Abruf fehlschlägt
  * `false`: Claude Code blockiert den Start nicht beim Abruf, obwohl es bei einem Start mit Anmeldung bis zu fünf Sekunden auf den Abruf wartet
* **Standard**: `false`

```json managed-settings.json theme={null}
{
  "forceRemoteSettingsRefresh": true
}
```

Setzen Sie dies in einem MDM-Profil oder der verwalteten Einstellungsdatei, um einen Fail-Closed-Start durchzusetzen, bevor die erste Server-Payload ankommt. Claude Code wendet die Überprüfung nur in Sitzungen an, die vom Server verwaltete Einstellungen abrufen, sodass eine Sitzung, die [diese nicht abruft](https://code.claude.com/docs/de/server-managed-settings.md#platform-availability), ohne Wartezeit startet. Die `claude auth`-Unterbefehle sind ausgenommen, sodass Benutzer sich erneut authentifizieren können, wenn abgelaufene Anmeldedaten der Grund für den fehlgeschlagenen Abruf sind. Siehe [Fail-Closed-Start durchsetzen](https://code.claude.com/docs/de/server-managed-settings.md#enforce-fail-closed-startup).

### `managedSourcesBehavior`

Wählen Sie, ob Claude Code nur die höchste Priorität [verwaltete Quelle](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources) anwendet, die Ihre Organisation bereitstellt, oder alle Admin-Quellen kombiniert, die sie bereitstellt. Standardmäßig nimmt Claude Code die höchste Prioritätsquelle, die einen [Richtlinienschlüssel](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources) trägt, und ignoriert den Rest. Ein Richtlinienschlüssel ist jeder Einstellungsschlüssel außer diesem und `wslInheritsWindowsSettings`. Bei diesem Standardverhalten trägt eine `managed-settings.json`-Datei, sobald vom Server verwaltete Einstellungen oder eine MDM-Richtlinie einen Richtlinienschlüssel bereitstellen, nur die [Schlüssel bei, die Claude Code aus jeder Admin-Quelle liest](https://code.claude.com/docs/de/managed-settings.md#keys-read-from-every-admin-source). Mit `"merge"` trägt jede Admin-Quelle, die Sie bereitstellen, ihre Schlüssel zu einer kombinierten Richtlinie bei. Erfordert Claude Code v2.1.242 oder später.

Setzen Sie `"merge"` nur dort, wo jede Quelle, die [unter Ihrer höchsten eingestuft](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources) ist, unter der Kontrolle eines Administrators steht, da Claude Code dann Einträge aus einer niedrigeren Quelle, wie z. B. `permissions.allow`-Regeln, zur Richtlinie hinzufügt.

* **Bereich**: [`Managed`](#scopes). Claude Code liest diesen Schlüssel aus der höchsten Prioritätsquelle, die entweder diesen Schlüssel oder einen Richtlinienschlüssel trägt, und ignoriert diesen Schlüssel in jeder Quelle, die niedriger eingestuft ist, sodass eine niedrigere Quelle sich nicht selbst zum Kombinieren mit der Quelle darüber anmelden kann. Weder die Windows HKCU-Registrierung noch [übergeordnete Einstellungen von einem Embedding-Host](https://code.claude.com/docs/de/managed-settings.md#let-an-embedding-host-add-policy) nehmen an der Zusammenführung teil.
* **Typ**: string, einer von:
  * `"first-wins"`: Die höchste Prioritätsquelle, die einen Richtlinienschlüssel trägt, liefert die Richtlinie, und niedrigere Quellen tragen nur die [Schlüssel bei, die Claude Code aus jeder Admin-Quelle liest](https://code.claude.com/docs/de/managed-settings.md#keys-read-from-every-admin-source)
  * `"merge"`: Jede Admin-Quelle, die Sie bereitstellen, trägt ihre Schlüssel bei, kombiniert nach den folgenden Regeln
* **Standard**: `"first-wins"`

Stellen Sie den Schlüssel in der höchsten Prioritätsquelle bereit, die Sie bereitstellen. Ein Computer, der niemals vom Server verwaltete Einstellungen erhält, benötigt den Schlüssel auch in seinem MDM-Profil, da Claude Code den Schlüssel aus der höchsten Prioritätsquelle liest, die ihn oder einen Richtlinienschlüssel trägt. Eine `managed-settings.json`-Datei ist die niedrigste Admin-Quelle, daher hat `"merge"` dort keine Quelle darunter, um sich damit zu kombinieren. In vom Server verwalteten Einstellungen sieht der Schlüssel so aus:

```json theme={null}
{
  "managedSourcesBehavior": "merge"
}
```

Unter `"merge"` kombiniert Claude Code jeden Schlüssel nach seiner Art. Diese Tabelle gibt die Regel für jede Art an. Die Zeilen für Einschränkungs-Allowlists, Werte-ganz-genommen und nur-höchste-Quelle benennen jeden Schlüssel, den sie abdecken, und die anderen Zeilen geben Beispiele:

| Art des Schlüssels | Wie Claude Code ihn kombiniert | Schlüssel |
| :- | :- | :- |
| Listen | Kombiniert Einträge aus jeder Quelle | [`permissions.allow`](#permissions-allow), [`sandbox.network.allowedDomains`](#sandbox-network-alloweddomains) und andere Listenschlüssel |
| Sperren | Wendet den strengsten Wert an, den eine Quelle setzt. Wenn keine Quelle einen strengen Wert setzt, wendet einen lockereren Wert nur aus der höchsten Quelle an | [`allowManagedPermissionRulesOnly`](#allowmanagedpermissionrulesonly), [`permissions.disableBypassPermissionsMode`](#permissions-disablebypasspermissionsmode) und andere Boolean- oder Enum-Sperren |
| Einschränkungs-Allowlists | Nimmt die Liste ganz aus der höchsten Quelle, die sie setzt, ohne Einträge aus niedrigeren Quellen hinzuzufügen. Wenn die höchste Quelle keine setzt, nimmt sie ganz aus der nächsten Quelle darunter | [`availableModels`](#availablemodels), [`allowedMcpServers`](#allowedmcpservers), [`allowedProviders`](#allowedproviders), [`strictKnownMarketplaces`](#strictknownmarketplaces), [`allowedChannelPlugins`](#allowedchannelplugins) und die [`fallbackModel`](#fallbackmodel)-Kette |
| Werte ganz genommen | Nimmt den Wert ganz aus der höchsten Quelle, die ihn setzt, ohne Einträge oder Felder aus niedrigeren Quellen zu kombinieren. Wenn die höchste Quelle ihn nicht setzt, nimmt ihn ganz aus der nächsten Quelle darunter | [`sandbox.credentials.awsPairs`](#sandbox-credentials-awspairs), [`sandbox.ripgrep`](#sandbox-ripgrep) |
| Bereitgestellte MCP-Server | Kombiniert die Servernamen aus jeder Quelle. Wenn zwei Quellen denselben Namen setzen, wendet den ganzen Eintrag der höheren Quelle an | [`managedMcpServers`](#managedmcpservers) |
| Nur aus der höchsten Prioritätsquelle lesen | Liest den Schlüssel nur aus der höchsten Prioritätsquelle, die einen Richtlinienschlüssel trägt, sodass der Wert einer niedrigeren Quelle ignoriert wird, auch wenn die höchste Quelle keinen setzt | [`apiKeyHelper`](#apikeyhelper), [`awsAuthRefresh`](#awsauthrefresh), [`awsCredentialExport`](#awscredentialexport), [`gcpAuthRefresh`](#gcpauthrefresh), [`otelHeadersHelper`](#otelheadershelper), `proxyAuthHelper`, [`forceLoginOrgUUID`](#forceloginorguuid), die `"claudeai"`- und `"console"`-Werte von [`forceLoginMethod`](#forceloginmethod), [`parentSettingsBehavior`](#parentsettingsbehavior), [`modelPicker`](#modelpicker), [`policyHelper`](#policyhelper), [`permissions.defaultMode`](#permissions-defaultmode) |
| `env` | [Zusammenführung pro Variable über Admin-Quellen](https://code.claude.com/docs/de/managed-settings.md#keys-read-from-every-admin-source), unter sowohl `"first-wins"` als auch `"merge"` | [`env`](#env) |
| Jeder andere Schlüssel | Nimmt den Wert aus der höchsten Quelle, die ihn setzt | [`cleanupPeriodDays`](#cleanupperioddays), [`model`](#model) |

Das Nehmen von `sandbox.credentials.awsPairs` und `sandbox.ripgrep` ganz erfordert Claude Code v2.1.257 oder später.

Einige Schlüssel fügen eine Bedingung hinzu, die die Tabelle nicht zeigt:

* **[`policyHelper`](#policyhelper)**: Claude Code berücksichtigt ihn nur, wenn die höchste Quelle, die einen Richtlinienschlüssel trägt, eine MDM-Richtlinie oder eine verwaltete Einstellungsdatei ist, sodass unter vom Server verwalteten Einstellungen sie nicht angewendet wird.
* **[`modelOverrides`](#modeloverrides)**: Paare mit `availableModels`. Claude Code nimmt `modelOverrides` aus der höchsten Quelle, die ihn setzt, es sei denn, eine höhere Quelle setzt `availableModels` ohne `modelOverrides`. In diesem Fall ignoriert es `modelOverrides` aus jeder Quelle.
* **[`forceLoginGatewayUrl`](#forcelogingatewayurl), [`gatewayInternalNetworks`](#gatewayinternalnetworks) und der `"gateway"`-Wert von [`forceLoginMethod`](#forceloginmethod)**: Claude Code liest sie nie aus vom Server verwalteten Einstellungen, sodass ein Wert dort weder angewendet wird noch einen in einer MDM-Richtlinie oder verwalteten Einstellungsdatei gesetzten Wert verbirgt. Unter den Admin-Quellen auf dem Computer liefert nur die höchste eingestufte, die einen Richtlinienschlüssel trägt, sie, unabhängig davon, ob vom Server verwaltete Einstellungen auch vorhanden sind.
* **[`allowedProviders`](#allowedproviders)**: Nach der Regel der Tabelle begrenzt die eigene Liste des Computers das Ergebnis weiterhin, wie im Hinweis unter „Bereich“ seines Eintrags angegeben.

Um zu bestätigen, welche Quellen auf einem Computer kombiniert wurden, führen Sie `/status` aus und [lesen Sie die Zeile `Setting sources`](https://code.claude.com/docs/de/managed-settings#read-the-source-in-/status).

### `parentSettingsBehavior`

Wählen Sie, ob Claude Code verwaltete Einstellungen anwendet, die von einem Embedding-Host-Prozess bereitgestellt werden, wie z. B. dem Agent SDK oder einer IDE-Erweiterung, wenn auch eine admin-bereitgestellte verwaltete Ebene vorhanden ist. Mit `"first-wins"` verwirft Claude Code die vom Host bereitgestellten Einstellungen; mit `"merge"` wendet es sie unter der Admin-Ebene durch einen restriktiv-nur-Filter an. Setzen Sie `"merge"`, wenn ein Host seine eigenen Einschränkungen an die Sitzungen übergeben muss, die er startet, z. B. Claude Desktop, das die Egress-Allowlist eines Gateways bereitstellt.

* **Bereich**: [`Managed`](#scopes). Claude Code liest ihn aus der höchsten Priorität admin-kontrollierten verwalteten Quelle.
* **Typ**: string, einer von:
  * `"first-wins"`: Claude Code verwirft die vom Host bereitgestellten Einstellungen, wenn eine admin-bereitgestellte verwaltete Ebene vorhanden ist
  * `"merge"`: Claude Code wendet die vom Host bereitgestellten Einstellungen unter der Admin-Ebene durch einen restriktiv-nur-Filter an
* **Standard**: `"first-wins"`

```json managed-settings.json theme={null}
{
  "parentSettingsBehavior": "merge"
}
```

Dieser Schlüssel hat keine Auswirkung, wenn keine admin-bereitgestellte verwaltete Ebene vorhanden ist: Die Einstellungen des Hosts gelten dann als einzige verwaltete Ebene, immer noch gefiltert auf restriktive Werte. Für die Grenzen des Filters und wie die verwalteten Quellen interagieren, siehe [Übergeordnete Einstellungen von Embedding-Hosts](https://code.claude.com/docs/de/managed-settings.md#parent-settings-from-embedding-hosts) und [Übergeordnete Einstellungen einschränken](https://code.claude.com/docs/de/claude-apps-gateway#restrict-parent-settings).

### `policyHelper`

Führen Sie eine ausführbare Datei aus, die Sie bereitstellen, die verwaltete Einstellungen beim Start berechnet, sodass Sie Richtlinien von Geräteposition, Identität oder einem Remote-Service ableiten können, anstatt von einer statischen Datei. Claude Code führt den Helper aus, bevor er den ersten Prompt akzeptiert, und behandelt die Einstellungen, die er ausgibt, als die verwalteten Einstellungen für die Sitzung.

* **Bereich**: [`Managed`](#scopes). Lesen Sie aus der macOS plist, der Windows HKLM-Registrierung oder der verwalteten Einstellungsdatei. Claude Code liest den Schlüssel aus der höchsten Priorität verwalteten Quelle, die einen [Richtlinienschlüssel](https://code.claude.com/docs/de/managed-settings.md#how-claude-code-combines-managed-sources) trägt, und führt den Helper nur aus, wenn diese Quelle eine dieser drei ist; es ignoriert den Schlüssel in vom Server verwalteten Einstellungen, der HKCU-Registrierung und vom Host bereitgestellten übergeordneten Einstellungen.
* **Typ**: Objekt mit `path`, `timeoutMs` und `refreshIntervalMs`
* **Standard**: nicht gesetzt, sodass kein Helper ausgeführt wird

Wenn vom Server verwaltete Einstellungen die Richtlinie beim Start bereitstellen, haben sie Vorrang vor der Quelle des Helpers und der Helper wird nicht ausgeführt.

Wenn ein späterer Einstellungsabruf meldet, dass die vom Server verwalteten Einstellungen entfernt wurden, führt Claude Code den Helper an diesem Punkt aus, anstatt auf den nächsten Start zu warten. Seine Ausgabe regelt den Rest der Sitzung, und ein Durchlauf, der fehlschlägt, beendet die Sitzung mit der gleichen Meldung wie ein [fehlgeschlagener Startup-Durchlauf](#helper-failures).

Dieses Beispiel führt den Helper mit einem 5-Sekunden-Timeout aus und führt ihn alle fünf Minuten erneut aus:

```json managed-settings.json theme={null}
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy",
    "timeoutMs": 5000,
    "refreshIntervalMs": 300000
  }
}
```

#### Schreiben Sie die Helper-Ausgabe

Claude Code führt den Helper ohne Argumente aus, setzt `CLAUDE_CODE_VERSION` in seiner Umgebung und liest eine JSON-Hülle aus stdout, begrenzt auf 1 MiB.

Legen Sie die Einstellungen unter einen `managedSettings`-Schlüssel. Ein bloßes Einstellungsobjekt ohne `managedSettings`-Schlüssel wird mit `managedSettings` undefined geparst und wendet nichts an, und Claude Code meldet keinen Fehler:

```json theme={null}
{
  "managedSettings": {
    "permissions": { "deny": ["Read(//etc/secrets/**)"] }
  }
}
```

Wenn der Helper `managedSettings` ausgibt, wird dieses Objekt die einzige verwaltete Einstellungsquelle für den Durchlauf: Claude Code ignoriert die MDM-, Datei- und HKCU-Quellen, liest die [quellübergreifenden Schlüssel](https://code.claude.com/docs/de/managed-settings.md#keys-read-from-every-admin-source) nur aus der Ausgabe des Helpers und führt niemals [übergeordnete Einstellungen](https://code.claude.com/docs/de/managed-settings.md#parent-settings-from-embedding-hosts) zusammen.

Die Startup-Überprüfung `forceRemoteSettingsRefresh` wird vor dem Helper ausgeführt und liest jede Admin-Quelle. Ein Helper, der mit `0` und einer Hülle beendet wird, die `managedSettings` auslässt, trägt keine verwalteten Einstellungen bei, und die anderen Quellen gelten wie üblich.

#### Helper-Fehler

Ein Helper-Durchlauf schlägt fehl, wenn:

* `path` bricht die Regeln in [`policyHelper.path`](#policyhelper-path).
* Keine reguläre Datei ist unter `path`. Claude Code prüft auf die Datei, bevor der Helper gestartet wird, innerhalb des gleichen `timeoutMs`-Budgets, sodass eine nicht reagierende Netzwerkbereitstellung den Durchlauf zum Fehlschlag bringen kann.
* Der Helper beendet sich mit nicht-null, läuft noch, wenn `timeoutMs` verstreicht, oder startet überhaupt nicht, z. B. weil er nicht ausführbar ist.
* Der Helper schreibt mehr als 1 MiB zu stdout oder stderr.
* stdout ist kein einzelnes JSON-Objekt, oder sein `managedSettings` hat eine [Schema-Verletzung, die Claude Code nicht reparieren kann](https://code.claude.com/docs/de/managed-settings.md#find-entries-claude-code-dropped).

Wenn der Startup-Durchlauf fehlschlägt, druckt Claude Code den Grund und weigert sich zu starten. Nach einem nicht-null-Exit enthält der Grund den stderr des Helpers oder seinen stdout, wenn stderr leer ist. Nach einem Timeout benennt der Grund das `timeoutMs`-Limit und enthält keine Ausgabe des Helpers. Die Weigerung deckt interaktive Sitzungen, `claude -p`, Agent SDK-Sitzungen, [Hintergrund-Sitzungen](https://code.claude.com/docs/de/agent-view.md) und die meisten Unterbefehle ab.

Die Weigerung ist absichtlich, sodass ein Helper, der Ausfallresilienz benötigt, aus seinem eigenen Cache bedienen und mit `0` beenden sollte.

Wenn eine Hintergrund-Aktualisierung fehlschlägt, behält Claude Code die letzte erfolgreiche Richtlinie bei, und `/status` zeigt die fehlgeschlagene Aktualisierung mit ihrem Grund an, bis eine Aktualisierung erfolgreich ist. Jede Aktualisierung wird unter den gleichen `timeoutMs`- und Fehlerregeln wie der Startup-Durchlauf ausgeführt.

Mit `--debug` schreibt Claude Code den stderr des Helpers aus jedem Durchlauf in das [Debug-Log](https://code.claude.com/docs/de/debug-your-config.md).

Claude Code meldet einen ungültigen `policyHelper`-Wert als einen [gelöschten Eintrag](https://code.claude.com/docs/de/managed-settings.md#find-entries-claude-code-dropped) und startet die Sitzung auf den verbleibenden verwalteten Einstellungen ohne Ausführung eines Helpers. Ungültige Werte umfassen einen bloßen Pfad-String und einen `timeoutMs` unter [seinem Minimum](#policyhelper-timeoutms).

Um einen Helper auszuschalten, entfernen Sie den Schlüssel aus der Quelle, die ihn setzt.

### `policyHelper.path`

Benennen Sie die ausführbare Datei des Helpers, die Claude Code ausführt. Für das, was passiert, wenn der Pfad die folgenden Regeln bricht, siehe [Helper-Fehler](#helper-failures).

* **Bereich**: [`Managed`](#scopes). Lesen Sie aus der macOS plist, der Windows HKLM-Registrierung oder der verwalteten Einstellungsdatei, wo [`policyHelper`](#policyhelper) gelesen wird.
* **Typ**: string, ein absoluter Pfad in normalisierter Form, ohne `.` oder `..` Segmente; unter Windows ein Laufwerk-Buchstaben- oder UNC-Pfad, der in `.exe` endet
* **Standard**: keine; erforderlich, wenn `policyHelper` gesetzt ist

```json managed-settings.json theme={null}
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy"
  }
}
```

### `policyHelper.timeoutMs`

Legen Sie fest, wie lange Claude Code auf den Helper wartet, bevor der Durchlauf als fehlgeschlagen behandelt wird. Ein abgelaufener Durchlauf schlägt auf die gleiche Weise fehl wie ein nicht-null-Exit, sodass Claude Code beim Start sich weigert zu starten.

* **Bereich**: [`Managed`](#scopes). Lesen Sie aus der macOS plist, der Windows HKLM-Registrierung oder der verwalteten Einstellungsdatei, wo [`policyHelper`](#policyhelper) gelesen wird.
* **Typ**: integer, Millisekunden, Minimum `1000`
* **Standard**: `10000`

```json managed-settings.json theme={null}
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy",
    "timeoutMs": 5000
  }
}
```

### `policyHelper.refreshIntervalMs`

Lassen Sie Claude Code den Helper im Hintergrund in einem Intervall erneut ausführen, sodass Richtlinienänderungen eine laufende Sitzung erreichen. Wenn eine Aktualisierung erfolgreich ist, ersetzt ihre Ausgabe die vorherigen verwalteten Einstellungen ohne einen Neustart; wenn eine Aktualisierung fehlschlägt, behält Claude Code die Richtlinie, die es bereits hat.

* **Bereich**: [`Managed`](#scopes). Lesen Sie aus der macOS plist, der Windows HKLM-Registrierung oder der verwalteten Einstellungsdatei, wo [`policyHelper`](#policyhelper) gelesen wird.
* **Typ**: integer, Millisekunden: `0` zum Deaktivieren der Aktualisierung, andernfalls mindestens `60000`
* **Standard**: nicht gesetzt, sodass Claude Code den Helper einmal beim Start ausführt

Dieses Beispiel führt den Helper alle fünf Minuten erneut aus:

```json managed-settings.json theme={null}
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy",
    "refreshIntervalMs": 300000
  }
}
```

### `wslInheritsWindowsSettings`

Lassen Sie Claude Code auf WSL verwaltete Einstellungen aus der Windows-Richtlinienkette lesen, wobei HKLM und die Windows-verwaltete Einstellungsdatei Vorrang vor `/etc/claude-code` und HKCU darunter haben. Während die Kette aktiv ist, liest Claude Code `/etc/claude-code` nur, wenn [kein Windows-Admin-Dokument vorhanden ist](https://code.claude.com/docs/de/managed-settings.md#present-admin-documents), weder im HKLM-Registrierungswert noch im Ordner `C:\Program Files\ClaudeCode\`. Setzen Sie dies, um die Richtlinie, die Sie bereits unter Windows bereitstellen, auf WSL-Sitzungen auf dem gleichen Computer zu erweitern, sodass sie den gleichen Regeln wie Host-Sitzungen folgen. Claude Code berücksichtigt ihn nur, wenn er im HKLM-Registrierungsschlüssel oder in einer verwalteten Einstellungsdatei oder Drop-in unter `C:\Program Files\ClaudeCode\` gesetzt ist, die beide Windows-Admin-Schreibzugriff erfordern.

* **Bereich**: [`Managed`](#scopes). In einer admin-kontrollierten Windows-Quelle.
* **Typ**: Boolean
  * `true`: Claude Code auf WSL liest verwaltete Einstellungen aus der Windows-Richtlinienkette und liest `/etc/claude-code` nur, wenn kein Windows-Admin-Dokument vorhanden ist
  * `false`: WSL liest nur `/etc/claude-code`
* **Standard**: `false`, sodass WSL nur `/etc/claude-code` liest

```json managed-settings.json theme={null}
{
  "wslInheritsWindowsSettings": true
}
```

Sobald eine Admin-Quelle die Kette einschaltet, tritt die HKCU-Richtlinie auf WSL nur bei, wenn HKCU auch den Schlüssel auf `true` setzt. Diese Kopie schaltet die Kette nicht von selbst ein. Eine Windows-Quelle, die nur diesen Schlüssel enthält, gesetzt auf `true` oder `false`, zählt nicht als Richtlinienquelle, sodass eine niedrigere Prioritätsquelle immer noch die Richtlinie liefert. Dieser Schlüssel hat keine Auswirkung auf natives Windows.

Claude Code liest `true` und `false` mit oder ohne Anführungszeichen und liest `null` als Entfernen des Schlüssels. Eine admin-kontrollierte Windows-Quelle, die einen anderen Wert enthält, zählt als [vorhandenes Admin-Dokument](https://code.claude.com/docs/de/managed-settings.md#present-admin-documents) mit eingeschalteter Kette: Weder `/etc/claude-code` noch HKCU gelten, und eine Warnung beim Start benennt den Schlüssel. Ein HKLM-Wert oder eine Datei im Windows-Ordner, die existiert, aber nicht gelesen werden kann, verhindert ebenfalls, dass `/etc/claude-code` gilt, unabhängig davon, ob die Kette eingeschaltet ist. Erfordert Claude Code v2.1.282 oder später.

## Globale Konfigurationseinstellungen

Speichern Sie diese Schlüssel in `~/.claude.json`, nicht in einer Einstellungsdatei. Claude Code ignoriert sie überall sonst. Claude Code und `/config` schreiben die meisten davon für Sie, und Sie können sie auch manuell bearbeiten.

### `autoConnectIde`

Verbinden Sie sich automatisch mit einer laufenden IDE, wenn Sie Claude Code von einem externen Terminal aus starten. Erscheint in `/config` als **Auto-Verbindung zur IDE (externes Terminal)**, wenn Sie Claude Code außerhalb eines VS Code- oder JetBrains-Terminals ausführen.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code verbindet sich automatisch mit einer laufenden IDE, wenn Sie es von einem externen Terminal aus starten
  * `false`: Claude Code verbindet sich nicht automatisch von einem externen Terminal aus; innerhalb eines VS Code- oder JetBrains-Terminals oder mit `--ide` verbindet es sich trotzdem
* **Standard**: `false`
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_AUTO_CONNECT_IDE`](https://code.claude.com/docs/de/env-vars) hat Vorrang vor diesem Schlüssel für eine Sitzung, in beide Richtungen

```json ~/.claude.json theme={null}
{
  "autoConnectIde": true
}
```

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `autoInstallIdeExtension`

Installieren Sie die Claude Code IDE-Erweiterung automatisch, wenn Sie Claude Code von einem VS Code-Terminal aus ausführen. Erscheint in `/config` als **Auto-Install IDE-Erweiterung**, wenn Sie Claude Code innerhalb eines VS Code- oder JetBrains-Terminals ausführen.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code installiert die IDE-Erweiterung automatisch, wenn Sie es von einem VS Code-Terminal aus ausführen
  * `false`: Claude Code installiert die Erweiterung nicht automatisch
* **Standard**: `true`
* **Überschreibungen pro Sitzung**: [`CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL`](https://code.claude.com/docs/de/env-vars) auf `1` gesetzt überspringt die Installation für eine Sitzung, auch wenn dieser Schlüssel `true` ist

```json ~/.claude.json theme={null}
{
  "autoInstallIdeExtension": false
}
```

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `claudeInChromeDefaultEnabled`

Starten Sie jede interaktive CLI-Sitzung mit aktivierter [Chrome-Integration](https://code.claude.com/docs/de/chrome.md), ohne jedes Mal `--chrome` übergeben zu müssen. Wenn Sie [`claude remote-control`](https://code.claude.com/docs/de/remote-control) ausführen, folgt auch eine Sitzung, die dadurch für einen Ihrer [Projekt](https://code.claude.com/docs/de/claude-projects.md)-Threads gestartet wird, diesem Schlüssel, außer im Modus `bypassPermissions`. Ab Claude Code v2.1.287 gilt dieser Schlüssel auch für Sitzungen in der [VS Code-Erweiterung](https://code.claude.com/docs/de/vs-code.md#automate-browser-tasks-with-chrome): siehe [Chrome standardmäßig aktivieren](https://code.claude.com/docs/de/chrome.md#enable-chrome-by-default).

Wenn Sie `/chrome` ausführen und **Standardmäßig aktiviert** auswählen, wird dieser Schlüssel für Sie gesetzt. Erscheint in `/config` als **Claude in Chrome standardmäßig aktiviert**.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code aktiviert die Chrome-Integration, wenn eine interaktive CLI-Sitzung startet, so wie beim Übergeben von `--chrome`. In der VS Code-Erweiterung verbinden sich Sitzungen beim Start mit dem Browser
  * `false`: Interaktive CLI-Sitzungen starten mit deaktivierter Chrome-Integration, und Claude Code [bietet die Einrichtung](https://code.claude.com/docs/de/chrome.md#install-the-extension-when-claude-asks) nicht mehr an. Übergeben Sie `--chrome`, um sie für eine interaktive Sitzung zu aktivieren. In der VS Code-Erweiterung verbindet sich eine Sitzung, wenn Sie `@browser` eingeben, wie bei nicht gesetztem Schlüssel
* **Standard**: nicht gesetzt, sodass die Chrome-Integration deaktiviert ist und Claude Code die Einrichtung weiterhin anbieten kann
* **Überschreibungen pro Sitzung**: `--chrome` und [`--no-chrome`](https://code.claude.com/docs/de/cli-reference) haben für eine interaktive Sitzung Vorrang vor diesem Schlüssel

```json ~/.claude.json theme={null}
{
  "claudeInChromeDefaultEnabled": true
}
```

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `copyFullResponse`

Lassen Sie [`/copy`](https://code.claude.com/docs/de/commands) jedes Mal die vollständige Antwort kopieren, ohne die Auswahl anzuzeigen. Wenn Sie in dieser Auswahl **Immer vollständige Antwort kopieren** wählen, wird dieser Schlüssel auf `true` gesetzt. Erscheint in `/config` als **/copy-Auswahl überspringen**.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: Boolean
  * `true`: `/copy` kopiert die vollständige Antwort, ohne die Auswahl anzuzeigen
  * `false`: Wenn die Antwort Codeblöcke oder Blockzitate enthält, zeigt `/copy` eine Auswahl an, in der Sie einen Block oder die vollständige Antwort wählen
* **Standard**: `false`

```json ~/.claude.json theme={null}
{
  "copyFullResponse": true
}
```

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `copyOnSelect`

Kopieren Sie Text automatisch in Ihre Zwischenablage, wenn Sie die Auswahl mit der Maus in der [Vollbilddarstellung](https://code.claude.com/docs/de/fullscreen.md#use-the-mouse) oder [Agent-Ansicht](https://code.claude.com/docs/de/agent-view.md) beenden. Erscheint in `/config` als **Beim Auswählen kopieren**, während die Vollbilddarstellung aktiviert ist.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: Boolean
  * `true`: Claude Code kopiert Text in Ihre Zwischenablage, wenn Sie die Auswahl beenden
  * `false`: Das Auswählen von Text lässt Ihre Zwischenablage unverändert, und Sie [kopieren die Auswahl stattdessen mit einer Tastenkombination](https://code.claude.com/docs/de/fullscreen.md#use-the-mouse)
* **Standard**: `true`

```json ~/.claude.json theme={null}
{
  "copyOnSelect": false
}
```

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `defaultToAgentsView`

Öffnen Sie die [Agent-Ansicht](https://code.claude.com/docs/de/agent-view.md) statt einer neuen Konversation, wenn Sie `claude` ohne Argumente ausführen. Erscheint in `/config` als **Agent-Ansicht standardmäßig öffnen**, sofern die Agent-Ansicht nicht [ausgeschaltet](#disableagentview) ist.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: Boolean
  * `true`: `claude` ohne Argumente öffnet die Agent-Ansicht, sofern die Agent-Ansicht nicht [ausgeschaltet](#disableagentview) ist
  * `false`: `claude` ohne Argumente startet eine neue Konversation
* **Standard**: `false`

```json ~/.claude.json theme={null}
{
  "defaultToAgentsView": true
}
```

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `diffTool`

Wählen Sie, wo Claude Code den Diff einer `Edit`- oder `Write`-Änderung anzeigt, die es vorschlägt, wenn eine [VS Code](https://code.claude.com/docs/de/vs-code.md)- oder [JetBrains](https://code.claude.com/docs/de/jetbrains.md#features)-IDE verbunden ist: `"auto"` öffnet es im Diff-Viewer der IDE, `"terminal"` behält es im Terminal. Erscheint in `/config` als **Diff-Tool** nur, wenn Claude Code mit einer VS Code- oder JetBrains-IDE verbunden ist.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: string, einer von:
  * `"auto"`: Claude Code öffnet den Diff im Diff-Viewer der IDE, wenn eine VS Code- oder JetBrains-IDE verbunden ist
  * `"terminal"`: Claude Code behält den Diff im Terminal
* **Standard**: `"auto"`

```json ~/.claude.json theme={null}
{
  "diffTool": "terminal"
}
```

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `externalEditorContext`

Wenn Sie `Ctrl+G` drücken, öffnet Claude Code den Prompt, den Sie gerade eingeben, in Ihrem [externen Editor](https://code.claude.com/docs/de/interactive-mode.md#general-controls). Mit diesem Schlüssel aktiviert, startet der Editor-Puffer mit Claudes vorheriger Antwort als `#`-Kommentarzeilen, damit Sie sie lesen können, während Sie schreiben, und Claude Code entfernt diese Zeilen, wenn Sie speichern. Erscheint in `/config` als **Letzte Antwort im externen Editor anzeigen**.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: Boolean
  * `true`: Der Editor-Puffer startet mit Claudes vorheriger Antwort als `#`-Kommentarzeilen, die Claude Code beim Speichern entfernt
  * `false`: Der Editor-Puffer öffnet sich nur mit Ihrem Prompt
* **Standard**: `false`

```json ~/.claude.json theme={null}
{
  "externalEditorContext": true
}
```

Mit aktiviertem Schlüssel sieht der Puffer, den Claude Code öffnet, so aus, und nur der Text unter der Markierungszeile wird als Ihr Prompt gesendet:

```text theme={null}
# ─── Claudes letzte Antwort (zur Referenz; beim Speichern entfernt) ───
# Ich habe die Wiederholungsschleife zu fetchUser in src/api.ts hinzugefügt
# und einen Test für den Timeout-Fall. Soll ich dasselbe Retry in
# fetchOrders einbauen?
# ─── Schreiben Sie Ihre Antwort unter dieser Zeile ──────────────────────

Ja, und begrenzen Sie es auf drei Versuche.
```

Claude Code behält die letzten 50 Zeilen der Antwort und markiert den Schnitt mit `# … (frühere Ausgabe gekürzt)`.

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `leftArrowOpensAgents`

Drücken Sie `←` in einem leeren Prompt, um [die Sitzung in den Hintergrund zu verschieben und die Agent-Ansicht zu öffnen](https://code.claude.com/docs/de/agent-view.md#switch-sessions-without-leaving-the-terminal). Setzen Sie diesen Schlüssel auf `false`, um diese Tastenkombination auszuschalten. Erscheint in `/config` als **← öffnet Agenten**, wenn die Agent-Ansicht verfügbar ist.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: Boolean
  * `true`: Das Drücken von `←` in einem leeren Prompt in einer Sitzung, die Sie im Terminal gestartet haben, verschiebt diese in den Hintergrund und öffnet die Agent-Ansicht
  * `false`: Claude Code schaltet die Tastenkombination aus; in einer Sitzung, [mit der Sie sich aus der Agent-Ansicht verbunden haben](https://code.claude.com/docs/de/agent-view.md#attach-to-a-session), trennt `←` in einem leeren Prompt die Verbindung weiterhin
* **Standard**: `true`

```json ~/.claude.json theme={null}
{
  "leftArrowOpensAgents": false
}
```

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `permissionExplainerEnabled`

> [!WARNING]
>
> Entfernt in v2.1.257, zusammen mit der `Ctrl+E`-Befehlserklärung in Bash- und PowerShell-Berechtigungsabfragen. Das Setzen hat keine Auswirkung auf aktuelle Versionen.

Bis v2.1.256 konnten Sie `Ctrl+E` in einer Bash- oder PowerShell-Berechtigungsabfrage drücken, um eine modellgenerierte Erklärung des Befehls zu sehen, und diesen Schlüssel auf `false` setzen, um diese Tastenkombination auszuschalten.

* **Geltungsbereich**: [`Global config`](#scopes). Auf v2.1.256 und früher.
* **Typ**: Boolean
* **Standard**: `true`

### `prStatusFooterEnabled`

Zeigen Sie in der Fußzeile des Prompts ein Badge für den offenen Pull Request oder Merge Request des aktuellen Branches an, mit einer farbigen Unterstreichung, die dessen [Status](https://code.claude.com/docs/de/interactive-mode.md#pr-review-status) anzeigt. Erscheint in `/config` als **PR-Status in Fußzeile anzeigen**.

* **Geltungsbereich**: [`Global config`](#scopes)
* **Typ**: Boolean
  * `true`: Die Fußzeile zeigt das Badge unter den in [PR-Review-Status](https://code.claude.com/docs/de/interactive-mode.md#pr-review-status) beschriebenen Bedingungen an
  * `false`: Claude Code überspringt die Prüfung von Pull Requests und Merge Requests für die Fußzeile und zeigt dieses Badge nicht an. Eine Sitzung, [mit der Sie sich aus der Agent-Ansicht verbunden haben](https://code.claude.com/docs/de/agent-view.md#attach-to-a-session), kann weiterhin einen einfachen Link zu einem [mit ihr verknüpften](https://code.claude.com/docs/de/agent-view.md#pull-request-status) Pull Request anzeigen
* **Standard**: `true`

```json ~/.claude.json theme={null}
{
  "prStatusFooterEnabled": false
}
```

Claude Code ignoriert diesen Schlüssel in `settings.json`.

### `teammateDefaultModel`

> [!WARNING]
>
> Entfernt in v2.1.234, zusammen mit seiner `/config`-Zeile **Standard-Teamkollegen-Modell**. Das Setzen hat keine Auswirkung auf aktuelle Versionen.

Bis v2.1.233 setzten Sie diesen Schlüssel auf das Modell für [Agent-Team](https://code.claude.com/docs/de/agent-teams.md#specify-teammates-and-models)-Teamkollegen, für die Ihr Prompt kein Modell benannt hat: ein Alias wie `"sonnet"` oder `null`, um dem Modell des Leads zu folgen. Für das Modell, das Claude Code für solche Teamkollegen jetzt auswählt, siehe [Teamkollegen und Modelle angeben](https://code.claude.com/docs/de/agent-teams.md#specify-teammates-and-models).

* **Geltungsbereich**: [`Global config`](#scopes). Auf v2.1.233 und früher.
* **Typ**: string, ein Modell-Alias oder vollständige Modell-ID oder `null`
* **Standard**: nicht gesetzt

## Siehe auch

* [Berechtigungen konfigurieren](https://code.claude.com/docs/de/permissions.md): Regelsyntax, Berechtigungsmodi und Workspace-Vertrauen
* [Umgebungsvariablen](https://code.claude.com/docs/de/env-vars.md): jede `CLAUDE_*`, `ANTHROPIC_*` und Provider-Variable, die Claude Code liest
* [Für Claude verfügbare Tools](https://code.claude.com/docs/de/tools-reference.md): die integrierten Tools und welche Genehmigung benötigen
* [Beispieleinstellungsdateien](https://code.claude.com/docs/de/settings-example.md): eine persönliche Datei, eine Team-Datei und eine verwaltete Datei einer Organisation
* [Verwaltete Einstellungen einrichten](https://code.claude.com/docs/de/admin-setup.md): wie Organisationen entscheiden, was erzwungen werden soll
* [Verwaltete Einstellungen bereitstellen](https://code.claude.com/docs/de/managed-settings.md): Bereitstellungsmechanismen, Vorrang innerhalb der verwalteten Ebene und ungültige Einträge in verwalteten Einstellungen
* [Konfiguration debuggen](https://code.claude.com/docs/de/debug-your-config.md): `claude doctor` und der Dialog „Einstellungsfehler“
