Tous les paramètres

​

Index des paramètres

​

Modèle et réponses

​

advisorModel

• Portée : Tout fichier
• Type : chaîne, l’un des alias "fable", "opus", ou "sonnet", qui se résolvent à la version par défaut actuelle de Claude Code pour cette famille de modèles, ou un ID de modèle complet tel que "claude-opus-5-5"
• Par défaut : non défini, donc l’advisor est désactivé
• Remplacements par session : --advisor a la priorité sur cette clé pour une session. CLAUDE_CODE_DISABLE_ADVISOR_TOOL désactive l’advisor, et cette clé ne peut pas le réactiver

{
  "advisorModel": "opus"
}

​

alwaysThinkingEnabled

• Portée : Tout fichier
• Type : Booléen
  • true : aucun effet ; la réflexion est déjà activée
  • false : Claude Code désactive la réflexion étendue pour chaque session
• Par défaut : non défini, donc la réflexion est activée pour les modèles qui la supportent
• Remplacements par session : MAX_THINKING_TOKENS a la priorité sur cette clé pour une session : 0 désactive la réflexion, sous les mêmes limites de modèle et de fournisseur que false, et une valeur positive active la réflexion même quand cette clé est false. Sur les modèles de raisonnement adaptatif, le nombre lui-même est ignoré

{
  "alwaysThinkingEnabled": false
}

​

availableModels

• Portée : Tout fichier. Déployez-le dans les paramètres gérés pour l’appliquer à une organisation.
• Type : tableau d’alias de modèles ou d’ID
• Par défaut : non défini, donc chaque modèle est disponible

{
  "availableModels": ["sonnet", "haiku"]
}

​

availableModelsMatch

• Portée : Géré. Claude Code ignore la clé dans les paramètres utilisateur, de projet et locaux et dans --settings, avec un avertissement
• Type : chaîne, l’une de :
  • "prefix" : une entrée d’ID de modèle permet sa version et tout ID de modèle qui l’étend avec un autre segment
  • "exact" : une entrée d’ID de modèle permet uniquement la version qu’elle nomme, y compris les ID datés de cette version, donc "claude-opus-5" permet Opus 5 mais pas claude-opus-5-5. Un alias de famille comme "opus" permet toujours la famille entière, et les entrées best, opusplan, et default sont ignorées
• Par défaut : "prefix"

{
  "availableModels": ["claude-opus-5", "claude-sonnet-5"],
  "availableModelsMatch": "exact"
}

​

deniedModels

• Portée : Géré. Claude Code ignore la clé dans les paramètres utilisateur, de projet et locaux et dans --settings, avec un avertissement
• Type : tableau d’alias de modèles ou d’ID
  • Un alias de famille comme "opus" bloque chaque modèle de cette famille
  • Un ID de modèle comme "claude-opus-5-5" bloque cette version dans chaque orthographe, y compris les ID datés et spécifiques au fournisseur
  • Un ID de modèle sans version mineure, comme "claude-opus-5", bloque également les versions mineures ultérieures comme Opus 5.5. Écrivez "claude-opus-5-0" pour bloquer Opus 5 seul
  • Les entrées best, opusplan, et default sont ignorées
• Par défaut : non défini, donc aucun modèle n’est bloqué

{
  "availableModels": ["opus", "sonnet"],
  "deniedModels": ["claude-opus-5-5"]
}

​

effortLevel

• Portée : Tout fichier
• Type : chaîne, l’une de :
  • "low" : le moins de raisonnement, pour les tâches courtes, délimitées, sensibles à la latence qui ne sont pas sensibles à l’intelligence
  • "medium" : réduit l’utilisation des tokens pour le travail sensible aux coûts qui peut faire des compromis sur l’intelligence
  • "high" : équilibre l’utilisation des tokens et l’intelligence
  • "xhigh" : raisonnement plus profond avec une dépense de tokens plus élevée
• Par défaut : non défini
• Remplacements par session : --effort a la priorité sur cette clé pour une session, et CLAUDE_CODE_EFFORT_LEVEL a la priorité sur les deux

{
  "effortLevel": "xhigh"
}

​

enforceAvailableModels

• Portée : Tout fichier
• Type : Booléen
  • true : quand Par défaut se résoudrait à un modèle en dehors de availableModels, Claude Code le résout au premier modèle disponible de la liste
  • false : cette clé ne change pas comment Par défaut se résout
• Par défaut : false

{
  "availableModels": ["sonnet", "haiku"],
  "enforceAvailableModels": true
}

​

fallbackModel

• Portée : Tout fichier
• Type : tableau d’alias de modèles ou d’ID ; "default" se développe au modèle par défaut
• Par défaut : non défini, donc une demande échouée n’est pas réessayée sur un autre modèle
• Remplacements par session : --fallback-model a la priorité sur cette clé pour une session

{
  "fallbackModel": ["claude-sonnet-5", "claude-haiku-4-5"]
}

​

fastMode

• Portée : Tout fichier
• Type : Booléen
  • true : Claude Code active le mode rapide pour les sessions où il est disponible
  • false : le mode rapide reste désactivé
• Par défaut : non défini, donc le mode rapide est désactivé
• Remplacements par session : CLAUDE_CODE_DISABLE_FAST_MODE désactive le mode rapide pour une session, et cette clé ne peut pas l’activer

{
  "fastMode": true
}

​

fastModePerSessionOptIn

• Portée : Tout fichier
• Type : Booléen
  • true : un fastMode: true enregistré n’active plus le mode rapide au démarrage de la session, donc chaque personne exécute /fast dans chaque session où elle le souhaite ; un fastMode: true passé avec --settings compte toujours pour cette session sauf si les paramètres gérés définissent cette clé
  • false : un fastMode: true enregistré active le mode rapide au début de chaque session ultérieure
• Par défaut : false

{
  "fastModePerSessionOptIn": true
}

​

language

• Portée : Tout fichier
• Type : chaîne, tout nom de langue, comme "japanese", "spanish", ou "french" ; Claude Code ne le valide pas
• Par défaut : non défini ; les titres de session correspondent alors à la langue de votre conversation

{
  "language": "japanese"
}

​

maxEffortLevel

• Portée : Tout fichier. Déployez-le dans les paramètres gérés pour l’appliquer à une organisation. Quand plusieurs portées définissent une limite, la plus basse s’applique, donc une limite définie dans une portée ne peut pas être augmentée à partir d’une autre
• Type : chaîne, l’une de "low", "medium", "high", "xhigh", ou "max". Une valeur "max" ne définit aucune limite
• Par défaut : non défini, donc aucune limite ne s’applique
• Limites par modèle : ajoutez maxEffortLevel à l’entrée modelSettings d’un modèle. Cette entrée remplace cette clé pour le modèle uniquement dans la source de paramètres qui définit les deux, comme vos paramètres utilisateur ou une source gérée. Définissez "max" là pour exempter le modèle de la limite de cette source ; Claude Code applique toujours les limites d’autres sources

{
  "maxEffortLevel": "medium",
  "modelSettings": {
    "claude-sonnet-4-6": {
      "maxEffortLevel": "max"
    }
  }
}

​

model

• Portée : Tout fichier
• Type : chaîne, un alias de modèle ou un ID de modèle complet
• Par défaut : non défini, donc Claude Code utilise le modèle par défaut de votre compte
• Remplacements par session : --model a la priorité sur ANTHROPIC_MODEL, et les deux ont la priorité sur cette clé pour une session, y compris sur un model géré ; une liste availableModels s’applique toujours au choix

{
  "model": "claude-sonnet-5"
}

​

modelOverrides

• Portée : Tout fichier
• Type : objet mappant l’ID du modèle à l’ID du modèle du fournisseur
• Par défaut : non défini

{
  "modelOverrides": {
    "claude-opus-4-6": "arn:aws:bedrock:us-east-1:123456789012:inference-profile/example"
  }
}

​

modelPicker

• Portée : Utilisateur ou géré. Claude Code lit la clé à partir des paramètres gérés, --settings, et des paramètres utilisateur, et l’ignore dans les paramètres de projet et locaux donc un référentiel que vous clonez ne peut pas réétiqueter le sélecteur. Le plus élevé de ces trois qui définit la clé fournit la gamme entière, et Claude Code ne combine jamais les gammes de deux sources.
• Type : objet avec un tableau options de lignes et un Booléen replaceBuiltInOptions optionnel
• Par défaut : non défini, donc le sélecteur affiche la gamme intégrée

{
  "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"
      }
    ]
  }
}

​

Champs pour modelPicker

• Supprimée : une ligne que Claude Code ne peut pas servir, comme un modèle retiré ou un modèle auquel votre organisation n’a pas accès
• Grisée : une ligne que vous ne pouvez pas sélectionner encore, affichée avec la raison
• Aucune ligne ne survit : Claude Code conserve la gamme intégrée, filtrée par la liste d’autorisation comme d’habitude

​

modelPricing

• Portée : Géré. Déployez la clé via les paramètres gérés par le serveur, une politique MDM, un fichier managed-settings.json, ou un assistant de politique. Claude Code l’ignore dans les paramètres utilisateur, de projet et locaux, dans --settings, et sur Windows dans le registre HKCU inscriptible par l’utilisateur. Avec les paramètres gérés par le serveur, chaque session rapporte les coûts au prix catalogue jusqu’à ce que la récupération des paramètres de cette session ait confirmé le paramètre. Une application hôte qui intègre Claude Code et définit CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST peut fournir sa propre table via l’option SDK managedSettings, que Claude Code utilise uniquement quand aucune source gérée ne définit la clé et uniquement dans Claude Code v2.1.246 ou ultérieur.
• Type : objet avec un multiplier optionnel et une carte overrides optionnelle
• Par défaut : non défini, donc Claude Code rapporte le prix catalogue sauf si une application hôte fournit une table

{
  "modelPricing": {
    "multiplier": 0.85,
    "overrides": {
      "claude-sonnet-4-6": {
        "input": 2.4,
        "output": 12,
        "cacheRead": 0.24,
        "cacheWrite": 3
      }
    }
  }
}

​

Champs pour modelPricing

​

Quels modèles une ligne modelPricing s’applique à

• L’ID d’un modèle intégré : une clé que Claude Code lui-même utilise pour un modèle intégré, que cette clé soit l’ID du modèle lui-même, comme claude-sonnet-4-6, ou son ID Bedrock, Agent Platform, ou Foundry. Claude Code applique la ligne à chaque ID de snapshot daté et ID spécifique au fournisseur de ce modèle.
• Toute autre clé : une clé qui n’est pas l’ID d’un modèle intégré, comme un alias de modèle de passerelle. Claude Code applique la ligne à cet ID uniquement. Quand un ID de modèle correspond exactement à l’une de vos clés et tombe également sous une ligne clé par l’ID d’un modèle intégré, Claude Code utilise la correspondance exacte.
• Un profil d’inférence d’application Bedrock : une fois que Claude Code a résolu le profil au modèle vers lequel il route, via votre carte modelOverrides ou la recherche bedrock:GetInferenceProfile, Claude Code applique la ligne de ce modèle au profil.

​

modelSettings

• Portée : Tout fichier
• Type : objet mappant un nom de modèle à un objet avec n’importe lequel de ces champs :
  • effortLevel : l’un de "low", "medium", "high", ou "xhigh"
  • maxEffortLevel : le niveau d’effort le plus élevé auquel le modèle peut s’exécuter
  • autoCompactWindow : un nombre de tokens de 100000 à 1000000, ou "auto" pour la fenêtre ajustée au modèle. /autocompact enregistre ici. Pour ce modèle, la valeur a la priorité sur un autoCompactWindow de niveau supérieur dans le même fichier de paramètres. Nécessite Claude Code v2.1.288 ou ultérieur
• Par défaut : non défini

{
  "modelSettings": {
    "claude-opus-5-5": {
      "effortLevel": "high"
    }
  }
}

​

outputStyle

• Portée : Tout fichier
• Type : chaîne, le nom d’un style de sortie intégré ou personnalisé
• Par défaut : non défini, donc Claude Code utilise le style par défaut

{
  "outputStyle": "Explanatory"
}

​

promptCacheTtl

• Portée : Tout fichier
• Type : chaîne, l’une de :
  • "5m" : le cache se conserve pendant cinq minutes
  • "1h" : le cache se conserve pendant une heure
• Par défaut : non défini, donc chaque demande de conversation principale obtient sa durée de vie par défaut
• Remplacements par session : FORCE_PROMPT_CACHING_5M a la priorité sur tout le reste, puis CLAUDE_CODE_PROMPT_CACHE_TTL, puis cette clé, et enfin ENABLE_PROMPT_CACHING_1H

{
  "promptCacheTtl": "1h",
  "subagentPromptCacheTtl": "5m"
}

​

showThinkingSummaries

• Portée : Tout fichier
• Type : Booléen
  • true : vous voyez les résumés complets de la réflexion quand vous développez la réflexion avec Ctrl+O
  • false : l’API Anthropic rédige les blocs de réflexion et Claude Code affiche un stub réduit
• Par défaut : false

{
  "showThinkingSummaries": true
}

​

subagentPromptCacheTtl

• Portée : Tout fichier
• Type : chaîne, l’une de :
  • "5m" : le cache se conserve pendant cinq minutes
  • "1h" : le cache se conserve pendant une heure
• Par défaut : non défini, donc chacune de ces demandes obtient sa durée de vie par défaut
• Remplacements par session : FORCE_PROMPT_CACHING_5M a la priorité sur tout le reste, puis CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL, puis cette clé, puis ENABLE_PROMPT_CACHING_1H, qui demande la durée de vie d’une heure sur chaque demande. Pour où la valeur du frontmatter propre d’un sous-agent se classe, consultez Choisir la TTL vous-même

{
  "subagentPromptCacheTtl": "1h"
}

​

switchModelsOnFlag

• Portée : Tout fichier. Apparaît dans /config comme Changer de modèles quand un message est signalé, avec les options Basculer automatiquement et Demander à chaque fois.
• Type : Booléen
  • true : Claude Code bascule vers le modèle de secours et continue
  • false : dans une session interactive Claude Code fait une pause pour que vous puissiez choisir entre basculer et éditer l’invite ; où aucune boîte de dialogue ne peut s’afficher, comme une exécution -p, la demande signalée se termine comme une erreur
• Par défaut : non défini. Claude Code bascule automatiquement, bien qu’il puisse demander d’abord dans une session interactive

{
  "switchModelsOnFlag": false
}

​

ultracode

• Portée : Tout fichier
• Type : Booléen
  • true : les sessions commencent avec ultracode activé quand les workflows dynamiques sont activés pour vous et votre modèle supporte xhigh
  • false : les sessions commencent avec ultracode désactivé
• Par défaut : non défini, donc ultracode est désactivé
• Remplacements par session : /effort ultracode active ultracode pour une session sans cette clé, et /effort ultracode off le désactive pour une session quand cette clé est true. L’indicateur --effort ultracode l’active également pour une session, à l’effort xhigh, et nécessite Claude Code v2.1.203 ou ultérieur

{
  "ultracode": true
}

​

Paramètres de permission

​

allowManagedPermissionRulesOnly

• Le répertoire .claude/ d’un dépôt
• Vos répertoires ~/.claude/skills/ et ~/.claude/commands/, y compris les skills synchronisés depuis claude.ai
• Un répertoire --add-dir
• Les plugins déclarés avec un manifeste .claude-plugin dans ~/.claude/skills/ ou dans le .claude/skills/ du projet

• Portée : Managed
• Type : Booléen
  • true : les paramètres gérés deviennent la seule source de règles de permission
  • false : Claude Code applique les règles de permission des fichiers utilisateur, projet, local et --settings en plus des règles gérées
• Défaut : non défini, donc Claude Code applique les règles de permission des paramètres utilisateur, projet et local et de --settings, en plus des règles gérées

{
  "allowManagedPermissionRulesOnly": true
}

​

autoMode

• Portée : User or managed
• Type : objet avec des tableaux environment, allow, soft_deny et hard_deny de règles en prose, plus le Booléen classifyAllShell
• Défaut : non défini, donc le classificateur utilise uniquement ses règles intégrées

{
  "autoMode": {
    "soft_deny": ["$defaults", "Never run terraform apply"]
  }
}

​

autoMode.classifyAllShell

• Portée : User or managed. Lisez partout où autoMode est lu.
• Type : Booléen
  • true : pendant que le mode auto est actif, Claude Code envoie chaque commande Bash et PowerShell via le classificateur et suspend vos règles d’autorisation shell ; en dehors du mode auto, les règles s’appliquent toujours
  • false : le mode auto suspend uniquement les règles d’autorisation qui pourraient exécuter du code arbitraire, comme Bash(*) et Bash(python *) ; une commande qui correspond à toute autre règle d’autorisation ignore le classificateur sauf si elle porte des domaines autorisés par commande, et chaque autre commande shell le traverse
• Défaut : false

{
  "autoMode": {
    "classifyAllShell": true
  }
}

​

disableAutoMode

• Portée : Any file. Plus utile dans les paramètres gérés, où les utilisateurs ne peuvent pas le remplacer. Également accepté sous permissions comme permissions.disableAutoMode.
• Type : la chaîne "disable"
• Défaut : non défini

{
  "disableAutoMode": "disable"
}

​

permissions

• Portée : Any file
• Type : objet avec allow, ask, deny, additionalDirectories, blockReadsOutsideWorkingDirectories, defaultMode, disableBypassPermissionsMode et disableAutoMode
• Défaut : non défini

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

​

useAutoModeDuringPlan

• Portée : User, local, or managed. Un dépôt ne peut pas l’éteindre pour vous.
• Type : Booléen
  • true : identique à non défini ; quand le mode auto est disponible, le classificateur examine chaque commande shell pendant la planification au lieu de vous l’inviter, sauf les suppressions de chemin critique. Un false dans l’un de ces fichiers l’éteint toujours
  • false : vous obtenez une invite de permission pour chaque commande en dehors de l’ensemble intégré en lecture seule
• Défaut : true

{
  "useAutoModeDuringPlan": false
}

​

permissions.allow

• Portée : Any file
• Type : tableau de chaînes de règles de permission
• Défaut : non défini
• Remplacements par session : --allowedTools ajoute des règles d’autorisation pour une session, et une règle de blocage de n’importe quel fichier de paramètres bloque toujours un outil qu’elle nomme

{
  "permissions": {
    "allow": ["Bash(git diff *)", "Read(~/.zshrc)"]
  }
}

​

Syntaxe des règles de permission

​

permissions.ask

• Portée : Any file
• Type : tableau de chaînes de règles de permission
• Défaut : non défini

{
  "permissions": {
    "ask": ["Bash(git push *)"]
  }
}

​

permissions.deny

• Portée : Any file
• Type : tableau de chaînes de règles de permission
• Défaut : non défini
• Remplacements par session : --disallowedTools ajoute des règles de blocage pour une session à côté de cette clé

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

​

permissions.additionalDirectories

• Portée : Any file, avec des limites sur l’accès en écriture du sandbox que confèrent les entrées de projet et locales
• Type : tableau de chemins de répertoires
• Défaut : non défini
• Remplacements par session : --add-dir et /add-dir ajoutent des répertoires pour une session à côté de cette clé

{
  "permissions": {
    "additionalDirectories": ["../docs/"]
  }
}

​

permissions.blockReadsOutsideWorkingDirectories

• Les actions qu’aucun mode n’auto-approuve couvre quand une commande shell qui lit un tel chemin vous invite
• Les commandes sandboxées sous le blocage couvre ce qu’une commande sandboxée peut lire

• Portée : Any file. Un true dans n’importe quel fichier s’applique, donc un dépôt peut activer le blocage pour lui-même mais ne peut pas lever le vôtre.
• Type : Booléen
  • true : les outils de fichiers de Claude refusent les lectures en dehors des répertoires de travail
  • false : identique à non défini ; le blocage s’applique toujours si un autre fichier définit true
• Défaut : non défini, donc les lectures en dehors des répertoires de travail suivent votre mode de permission

{
  "permissions": {
    "blockReadsOutsideWorkingDirectories": true
  }
}

​

Commandes sandboxées sous le blocage

• L’isolation du système de fichiers est désactivée via sandbox.filesystem.disabled
• allowManagedReadPathsOnly est défini
• Le chemin du répertoire dans lequel vous avez démarré Claude Code contient un caractère glob comme *, ? ou [

• ~/.gitconfig
• Les fichiers config, ignore et attributes sous $XDG_CONFIG_HOME/git, qui par défaut est ~/.config/git
• Les fichiers que votre configuration git globale nomme via [include], [includeIf], core.excludesFile ou core.attributesFile

​

permissions.defaultMode

• Portée : Any file. auto et bypassPermissions ne prennent pas effet à partir des paramètres du projet ou local, donc définissez-les dans ~/.claude/settings.json à la place. Avant la v2.1.257, bypassPermissions prenait effet à partir de n’importe quel fichier. Pour les conversations que l’extension VS Code démarre, Claude Code lit uniquement les valeurs utilisateur, gérées et --settings.
• Type : chaîne, l’une de :
  • "default" : Claude Code exécute uniquement les lectures sans demander
  • "acceptEdits" : Claude Code exécute aussi les éditions de fichiers et les commandes courantes du système de fichiers comme mkdir et mv sans demander
  • "plan" : Claude Code lit et planifie mais bloque les éditions jusqu’à ce que vous approuviez un plan
  • "auto" : Claude Code exécute sans invites de routine ; avant que les actions telles que les commandes shell et les requêtes réseau s’exécutent, un classificateur en arrière-plan vérifie qu’elles s’alignent avec votre demande
  • "dontAsk" : Claude Code refuse automatiquement chaque appel qui inviterait autrement ; les lectures de fichiers dans vos répertoires de travail, les autres actions qui ne nécessitent pas d’approbation, et les outils pré-approuvés s’exécutent toujours, à l’exception des lectures depuis des chemins réseau
  • "bypassPermissions" : Claude Code exécute tout sans demander
  • "manual" : un alias pour "default"
• Défaut : non défini
• Remplacements par session : --permission-mode, et son équivalent --dangerously-skip-permissions pour bypassPermissions, ont priorité sur cette clé pour une session

{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

​

permissions.disableBypassPermissionsMode

• Portée : Any file. Généralement défini dans les paramètres gérés pour appliquer la politique organisationnelle.
• Type : la chaîne "disable"
• Défaut : non défini
• Remplacements par session : cette clé a priorité sur --dangerously-skip-permissions, que Claude Code rejette pendant que la clé est définie

{
  "permissions": {
    "disableBypassPermissionsMode": "disable"
  }
}

​

skipAutoPermissionPrompt

• Portée : User or managed. Un dépôt ne peut pas le définir pour vous.
• Type : Booléen
  • true : Claude Code ignore l’avis
  • false : identique à non défini ; l’avis apparaît une fois sauf si un de ces fichiers définit true
• Défaut : non défini, donc l’avis apparaît une fois

{
  "skipAutoPermissionPrompt": true
}

​

skipDangerousModePermissionPrompt

• Portée : User, local, or managed. Un dépôt non approuvé ne peut pas ignorer le dialogue pour vous.
• Type : Booléen
  • true : Claude Code ignore le dialogue de confirmation avant qu’une session entre en mode bypassPermissions
  • false : identique à non défini ; le dialogue apparaît sauf si un de ces fichiers définit true
• Défaut : non défini, donc le dialogue apparaît

{
  "skipDangerousModePermissionPrompt": true
}

​

Paramètres du sandbox

​

sandbox

• Scope : Any file
• Type : objet avec enabled, failIfUnavailable, autoAllowBashIfSandboxed, excludedCommands, allowUnsandboxedCommands, enableWeakerNestedSandbox, enableWeakerNetworkIsolation, allowAppleEvents, bwrapPath, socatPath, ignoreViolations et ripgrep, plus les objets filesystem, network et credentials
• Default : non défini, donc Claude Code exécute les commandes sans sandbox

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

​

sandbox.enabled

• Scope : Any file, avec des limites sur les paramètres de projet et locaux
• Type : Booléen
  • true : Claude Code met en sandbox les commandes Bash
  • false : les commandes Bash s’exécutent sans sandbox
• Default : false

{
  "sandbox": {
    "enabled": true
  }
}

​

sandbox.failIfUnavailable

• Scope : Any file, avec des limites sur les paramètres de projet et locaux
• Type : Booléen
  • true : Claude Code se termine avec une erreur au démarrage lorsque sandbox.enabled est true mais que le sandbox ne peut pas démarrer
  • false : Claude Code exécute les commandes sans sandbox lorsque le sandbox ne peut pas démarrer
• Default : false

{
  "sandbox": {
    "enabled": true,
    "failIfUnavailable": true
  }
}

​

sandbox.autoAllowBashIfSandboxed

• Scope : Any file
• Type : Booléen
  • true : Claude Code exécute les commandes Bash en sandbox sans demande de permission, sous réserve des règles deny et des règles ask limitées au contenu ; CLAUDE_CODE_SUBPROCESS_ENV_SCRUB désactive l’auto-allow
  • false : les commandes en sandbox passent par le flux de permission régulier, donc vos règles d’autorisation et le mode de permission décident. L’onglet Mode de /sandbox appelle ceci mode de permissions régulier
• Default : true

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": false
  }
}

​

sandbox.excludedCommands

• Scope : Any file, avec des limites sur les paramètres de projet et locaux
• Type : tableau de motifs de commande
• Default : non défini, donc aucune commande n’est exclue

{
  "sandbox": {
    "excludedCommands": ["docker *"]
  }
}

• Une commande commençant par sudo, eval ou xargs
• Un cd, pushd ou popd, où qu’il apparaisse dans l’appel
• Une substitution de commande, un sous-shell ou un bloc de contrôle de flux tel que if ou for
• Une redirection, comme docker build . > build.log, autre qu’une qui duplique uniquement un descripteur de fichier, comme 2>&1 le fait
• Un nom de commande qui provient d’une variable
• Un git clone, git init, git worktree add, git worktree move ou git bundle create avec un argument de chemin qui est absolu, commence par ~ ou contient un segment ..

​

sandbox.allowUnsandboxedCommands

• Scope : Any file, avec une limite sur les paramètres de projet et locaux
• Type : Booléen
  • true : Claude peut réessayer une commande en dehors du sandbox avec le paramètre dangerouslyDisableSandbox après que le sandbox l’ait bloquée
  • false : Claude Code ignore ce paramètre, donc tant que le sandbox est en cours d’exécution, les commandes que Claude exécute sont en sandbox, sauf si elles correspondent à une entrée excludedCommands
• Default : true

{
  "sandbox": {
    "enabled": true,
    "allowUnsandboxedCommands": false
  }
}

​

sandbox.filesystem

• Scope : Any file
• Type : objet avec les tableaux allowWrite, denyWrite, denyRead et allowRead, plus les booléens allowManagedReadPathsOnly et disabled
• Default : non défini, donc les limites de lecture et d’écriture par défaut s’appliquent

{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    }
  }
}

​

Préfixes de chemin du sandbox

• allowWrite et denyWrite : sur macOS, les caractères génériques fonctionnent. Sur Linux et WSL2, le sandbox monte des chemins concrets, donc Claude Code ignore une entrée qui contient *, ? ou [ une fois que le /** final est supprimé, et cette entrée n’a aucun effet. Claude Code ajoute les chemins de vos règles de permission Edit à ces listes, donc la même limite s’applique à elles, et l’onglet Config de /sandbox avertit des règles de permission Edit et Read qui contiennent des caractères génériques.
• denyRead et allowRead : les caractères génériques fonctionnent sur chaque plateforme. Sur Linux et WSL2, Claude Code développe une entrée de lecture aux chemins concrets qu’elle correspond, ce qu’il ne fait pas pour les listes d’écriture.

​

sandbox.filesystem.allowWrite

• Scope : Any file, avec des limites sur les paramètres de projet et locaux
• Type : tableau de chaînes de chemin, utilisant les préfixes de chemin du sandbox
• Default : non défini, donc les commandes en sandbox peuvent écrire dans le répertoire de travail, le répertoire temporaire propre à l’utilisateur, les répertoires que vous avez ajoutés avec --add-dir ou /add-dir, et les répertoires dans permissions.additionalDirectories

{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"]
    }
  }
}

​

sandbox.filesystem.denyWrite

• Scope : Any file
• Type : tableau de chaînes de chemin, utilisant les préfixes de chemin du sandbox
• Default : non défini

{
  "sandbox": {
    "filesystem": {
      "denyWrite": ["/etc", "/usr/local/bin"]
    }
  }
}

​

sandbox.filesystem.denyRead

• Scope : Any file
• Type : tableau de chaînes de chemin, utilisant les préfixes de chemin du sandbox
• Default : non défini, donc les commandes en sandbox conservent l’accès en lecture par défaut, qui inclut les fichiers d’identifiants tels que ~/.aws/credentials

{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/.aws/credentials"]
    }
  }
}

​

sandbox.filesystem.allowRead

• Scope : Any file, avec des limites sur les paramètres de projet et locaux
• Type : tableau de chaînes de chemin, utilisant les préfixes de chemin du sandbox
• Default : non défini

{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["."]
    }
  }
}

​

sandbox.filesystem.allowManagedReadPathsOnly

• Scope : Managed
• Type : Booléen
  • true : Claude Code honore uniquement les entrées allowRead des paramètres gérés
  • false : les entrées allowRead d’autres fichiers de paramètres peuvent être fusionnées
• Default : false

{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["~/work"],
      "allowManagedReadPathsOnly": true
    }
  }
}

​

sandbox.filesystem.disabled

• Scope : User or managed. Lorsque les paramètres gérés configurent sandbox.filesystem du tout, ou listent une entrée sandbox.credentials.files avec "mode": "deny", seuls les paramètres gérés peuvent la définir.
• Type : Booléen
  • true : Claude Code ignore l’isolation du système de fichiers et conserve l’isolation du réseau
  • false : l’isolation du système de fichiers reste activée
• Default : false, donc l’isolation du système de fichiers reste activée

{
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "disabled": true
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}

​

sandbox.ignoreViolations

• Scope : Any file, avec des limites sur les paramètres de projet et locaux
• Type : objet mappant une sous-chaîne de commande à un tableau de sous-chaînes de violation, généralement des chemins
• Default : non défini, donc chaque violation est signalée

{
  "sandbox": {
    "ignoreViolations": {
      "*": ["/etc/hosts"]
    }
  }
}

​

sandbox.enableWeakerNestedSandbox

• Scope : Any file, avec des limites sur les paramètres de projet et locaux
• Type : Booléen
  • true : le sandbox interne lie-monte le /proc existant du conteneur au lieu de monter un frais
  • false : le sandbox monte un /proc frais, ce qui ne fonctionne pas dans un conteneur Docker sans privilèges
• Default : false

{
  "sandbox": {
    "enabled": true,
    "enableWeakerNestedSandbox": true
  }
}

​

sandbox.enableWeakerNetworkIsolation

• Scope : Any file, avec des limites sur les paramètres de projet et locaux
• Type : Booléen
  • true : les commandes en sandbox sur macOS peuvent atteindre com.apple.trustd.agent
  • false : les commandes en sandbox sur macOS ne peuvent pas atteindre le service de confiance TLS système
• Default : false

{
  "sandbox": {
    "enabled": true,
    "enableWeakerNetworkIsolation": true
  }
}

​

sandbox.allowAppleEvents

• Scope : User or managed
• Type : Booléen
  • true : les commandes en sandbox sur macOS peuvent envoyer des Apple Events
  • false : les commandes en sandbox sur macOS ne peuvent pas envoyer des Apple Events, donc open et osascript échouent avec l’erreur -600
• Default : false

{
  "sandbox": {
    "enabled": true,
    "allowAppleEvents": true
  }
}

​

sandbox.ripgrep

• Scope : User or managed
• Type : objet avec command, le chemin vers le binaire ripgrep, et optionnellement args, un tableau d’arguments à ajouter en préfixe
• Default : non défini, donc le sandbox utilise le même binaire ripgrep que Claude Code. C’est le binaire fourni sauf si vous définissez USE_BUILTIN_RIPGREP sur 0

{
  "sandbox": {
    "ripgrep": {
      "command": "/usr/local/bin/rg"
    }
  }
}

​

sandbox.bwrapPath

• Scope : Managed. Claude Code le lit uniquement à partir des paramètres gérés afin qu’un fichier utilisateur, projet ou local ne puisse pas pointer le sandbox vers un binaire différent.
• Type : chaîne, un chemin absolu ; Claude Code abandonne un chemin relatif et revient à la recherche PATH
• Default : non défini, donc Claude Code trouve bwrap sur PATH

{
  "sandbox": {
    "enabled": true,
    "bwrapPath": "/opt/admin/bwrap"
  }
}

​

sandbox.socatPath

• Scope : Managed
• Type : chaîne, un chemin absolu ; Claude Code abandonne un chemin relatif et revient à la recherche PATH
• Default : non défini, donc Claude Code trouve socat sur PATH

{
  "sandbox": {
    "enabled": true,
    "socatPath": "/opt/admin/socat"
  }
}

​

sandbox.credentials

• Scope : Any file. Claude Code honore les entrées mask, allowPlaintextInject, awsPairs et sigv4 uniquement à partir des paramètres utilisateur, gérés et du flag --settings.
• Type : objet avec files, envVars, allowPlaintextInject, awsPairs et sigv4
• Default : non défini, donc aucun identifiant n’est protégé

{
  "sandbox": {
    "credentials": {
      "files": [{ "path": "~/.aws/credentials", "mode": "deny" }],
      "envVars": [{ "name": "GITHUB_TOKEN", "mode": "deny" }]
    }
  }
}

​

Entrées d’identifiants invalides dans les paramètres gérés

• Une entrée dans files ou envVars qui a toujours un path ou name valide et un mode de mask ou deny, comme une dont le motif extract n’a pas de groupe de capture, est dégradée à mode: "deny" avec un avertissement, donc l’identifiant reste bloqué, pas masqué, jusqu’à ce que vous corrigiez l’entrée. Une entrée files dégradée épingle filesystem.disabled comme une entrée deny explicite, et l’avertissement note que son bloc de lecture n’est pas appliqué si les paramètres gérés désactivent l’isolation du système de fichiers.
• Une entrée avec un mode inconnu ou un path ou name invalide est supprimée.
• Chaque cas avertit ; qu’une entrée soit dégradée ou supprimée, les entrées valides restantes sont toujours appliquées.

​

sandbox.credentials.files

• Scope : Any file. Claude Code abandonne les entrées mask de .claude/settings.json du projet et de .claude/settings.local.json local.
• Type : tableau d’objets, chacun avec path et un mode de "deny" ou "mask", plus les champs mask optionnels pour les fichiers
• Default : non défini, donc aucun fichier d’identifiants n’est protégé

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

​

Champs mask pour les fichiers

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

• Scope : Any file. Claude Code abandonne les entrées mask de .claude/settings.json du projet et de .claude/settings.local.json local.
• Type : tableau d’objets, chacun avec name et un mode de "deny" ou "mask", plus les champs mask optionnels pour les variables d’environnement
• Default : non défini, donc aucune variable d’environnement n’est protégée

{
  "sandbox": {
    "credentials": {
      "envVars": [
        { "name": "NPM_TOKEN", "mode": "deny" },
        { "name": "GITHUB_TOKEN", "mode": "mask", "injectHosts": ["api.github.com"] }
      ]
    }
  }
}

​

Champs mask pour les variables d’environnement

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