---
title: Outil d'exécution de code
url: https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool
description: Exécutez du code Python et bash dans un conteneur isolé pour analyser des données, générer des fichiers et itérer sur des solutions.
featureMetadata:
  status: ga
  zdr: not-eligible
  supportedModels:
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-opus-5-5
    - claude-opus-5
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-sonnet-4-6
    - claude-sonnet-4-5-20250929
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
  supportedPlatforms:
    Claude API: ga
    Claude Platform on AWS: ga
    Microsoft Foundry:
      availability: ga
      note: Sur [Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry), l'exécution de code nécessite un [déploiement hébergé sur Anthropic](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure).
  details:
    - Chaque modèle pris en charge accepte les trois [versions de l'outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#tool-versions). Sur Claude Haiku 4.5, l'appel d'outils programmatique et la persistance de l'état du REPL ne sont pas disponibles, de sorte que les versions plus récentes s'y comportent comme `code_execution_20250825`.
    - Pour [Claude Mythos Preview](https://anthropic.com/glasswing), l'exécution de code est prise en charge sur la Claude API et Microsoft Foundry.
---

Claude peut analyser des données, créer des visualisations, effectuer des calculs complexes, exécuter des commandes système, créer et modifier des fichiers, et traiter des fichiers téléversés directement au sein de la conversation API. L'outil d'exécution de code (« code execution tool ») permet à Claude d'exécuter des commandes Bash et de manipuler des fichiers, y compris d'écrire du code, dans un environnement sécurisé et isolé en « sandbox » (bac à sable).

**L'exécution de code est gratuite lorsqu'elle est utilisée avec la recherche web ou la récupération web (`web_search_20260209`, `web_fetch_20260209` ou ultérieur).** Lorsque l'un de ces outils figure dans votre requête, aucun frais supplémentaire n'est facturé pour l'exécution de code dans cette requête au-delà des coûts standard en tokens. Cela couvre à la fois l'exécution de code derrière le filtrage dynamique et tout code que Claude exécute directement. La tarification standard de l'exécution de code s'applique lorsqu'ils ne sont pas inclus.

L'exécution de code alimente également le filtrage dynamique dans les outils de [recherche web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool) et de [récupération web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-fetch-tool) : Claude filtre les résultats à l'intérieur de l'environnement d'exécution de code avant qu'ils n'atteignent la « context window » (fenêtre de contexte). Lorsque le filtrage dynamique s'exécute, l'API provisionne automatiquement l'exécution de code dont elle a besoin pour la requête, vous n'avez donc pas à ajouter l'outil d'exécution de code à votre requête pour cela.

<Note>
  Contactez-nous via le [formulaire de commentaires](https://forms.gle/LTAU6Xn2puCJMi1n6) pour partager vos retours sur cette fonctionnalité.
</Note>

## Versions de l'outil

L'outil d'exécution de code possède trois versions actuelles, et chaque [modèle pris en charge](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#compatibility) accepte les trois. Chaque version s'appuie sur la précédente :

* `code_execution_20250825` prend en charge les commandes Bash et les opérations sur les fichiers.
* `code_execution_20260120` ajoute la persistance de l'état REPL et l'[appel d'outils programmatique](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/programmatic-tool-calling) (« programmatic tool calling ») depuis l'intérieur de la sandbox. Claude Haiku 4.5 accepte les types d'outils `code_execution_20260120` et `code_execution_20260521`, mais l'appel d'outils programmatique et la persistance de l'état REPL qui en dépend n'y sont pas disponibles, de sorte que les versions plus récentes s'y comportent comme `code_execution_20250825`.
* `code_execution_20260521` est le même environnement d'exécution que `code_execution_20260120`. La différence est que la description de l'outil informe Claude de la limite de 90 secondes de temps réel sur chaque cellule Python dans l'appel d'outils programmatique, afin que Claude puisse planifier les cellules de longue durée. Une cellule qui dépasse la limite renvoie un résultat d'exécution de code normal avec un `return_code` non nul et un message d'état `detection_timeout` dans sa sortie. Ceci est distinct du [code d'erreur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#errors) `execution_time_exceeded`, que l'API renvoie lorsqu'une invocation d'outil entière dépasse le temps d'exécution maximal.

Aucune des trois versions de l'outil ne nécessite d'en-tête `anthropic-beta`. Les anciens en-têtes bêta d'exécution de code restent des options d'activation valides.

Les exemples de cette page utilisent `code_execution_20250825`, qui couvre les opérations Bash et sur fichiers qu'ils illustrent et se comporte de la même manière sur chaque modèle pris en charge ; utilisez `code_execution_20260120` ou ultérieur lorsque vous avez besoin de l'appel d'outils programmatique ou de la persistance de l'état REPL. Les outils actuels de [recherche web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool) et de [récupération web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-fetch-tool) (`web_search_20260209`, `web_fetch_20260209` et ultérieurs) nécessitent `code_execution_20260120` ou ultérieur comme version d'exécution de code.

La compatibilité des anciennes versions de l'outil avec les modèles plus récents n'est pas garantie. Lorsque vous adoptez un nouveau modèle, consultez [Versions de l'outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#tool-versions) et [Compatibilité](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#compatibility), et privilégiez la version de l'outil la plus récente que votre intégration prend en charge.

Pour vérifier si un modèle accepte l'outil d'exécution de code avant d'envoyer une requête, lisez sa valeur `capabilities.server_tools.code_execution.supported` depuis l'API Models. N'utilisez pas la valeur de premier niveau `capabilities.code_execution` à cette fin. Elle indique si le code exécuté dans cet outil peut appeler les autres outils de votre requête, comme dans l'appel d'outils programmatique. [Utiliser l'API Models](https://platform.claude.com/docs/fr/models/overview#using-the-models-api) décrit les deux champs.

<Note>
  Si vous utilisez encore l'ancienne version `code_execution_20250522` (Python uniquement), consultez [Mettre à niveau vers la dernière version de l'outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version) pour effectuer la migration.
</Note>

## Démarrage rapide

Voici un exemple qui demande à Claude d'effectuer un calcul :

<CodeGroup>
  ```bash cURL
  curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [
        {
          "role": "user",
          "content": "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
        }
      ],
      "tools": [
        {
          "type": "code_execution_20250825",
          "name": "code_execution"
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 4096 \
    --message '{
      role: user,
      content: "Use the code execution tool to calculate the mean and standard
        deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
    }' \
    --tool '{type: code_execution_20250825, name: code_execution}'
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
          }
      ],
      tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
  )

  print(response.to_json())
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content:
          "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      }
    ],
    tools: [{ type: "code_execution_20250825", name: "code_execution" }]
  });

  console.log(JSON.stringify(response));
  ```

  ```csharp C#
  AnthropicClient client = new();

  var message = await client.Messages.Create(new()
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [new() { Role = Role.User, Content = "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" }],
      Tools = [new CodeExecutionTool20250825()]
  });

  Console.WriteLine(message);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]")),
  	},
  	Tools: []anthropic.ToolUnionParam{
  		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.RawJSON())
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(4096L)
      .addUserMessage("Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]")
      .addTool(CodeExecutionTool20250825.builder().build())
      .build();

  Message response = client.messages().create(params);
  IO.println(ObjectMappers.jsonMapper().valueToTree(response));
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          [
              'role' => 'user',
              'content' => 'Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]',
          ],
      ],
      model: Model::CLAUDE_OPUS_5_5,
      tools: [new CodeExecutionTool20250825()],
  );

  echo json_encode($message, JSON_PRETTY_PRINT), PHP_EOL;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      }
    ],
    tools: [Anthropic::CodeExecutionTool20250825.new]
  )

  puts message.to_json
  ```
</CodeGroup>

La réponse entrelace des blocs `server_tool_use` (les commandes exécutées par Claude) avec leurs blocs de résultat d'outil, suivis du texte de Claude. Le niveau supérieur inclut également un objet `container` dont vous pouvez [réutiliser l'`id` entre les requêtes](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#container-reuse). Consultez [Format de réponse](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#response-format) pour la structure des blocs.

## Fonctionnement de l'exécution de code

Lorsque vous ajoutez l'outil d'exécution de code à votre requête API :

1. Claude évalue si l'exécution de code aiderait à répondre à votre question

2. L'outil fournit automatiquement à Claude les capacités suivantes :

   * **Commandes Bash :** exécuter des commandes shell pour les opérations système
   * **Opérations sur les fichiers :** créer, afficher et modifier des fichiers directement, y compris écrire du code

3. Claude peut utiliser n'importe quelle combinaison de ces capacités dans une seule requête

4. Toutes les opérations s'exécutent dans un conteneur sandbox sécurisé. Le conteneur n'a pas d'accès à Internet, Claude ne peut donc pas télécharger de paquets à l'exécution : seules les [bibliothèques préinstallées](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#pre-installed-libraries) sont disponibles

5. L'API exécute chaque commande côté serveur et renvoie les résultats à Claude au sein de la même requête, vous n'exécutez donc jamais de code ni ne renvoyez vous-même de blocs `tool_result`. Une exception survient lorsque Claude appelle l'un de vos outils client en parallèle de l'exécution de code : l'API renvoie l'appel d'exécution de code sans son résultat. Le résultat arrive dans une réponse ultérieure, après que vous avez renvoyé les blocs `tool_result` pour vos outils client

6. Chaque requête s'exécute dans un nouveau conteneur, sauf si vous retransmettez l'ID de conteneur d'une réponse précédente (voir [Réutilisation des conteneurs](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#container-reuse))

7. Claude fournit les résultats avec tous les graphiques, calculs ou analyses générés

Python est préinstallé dans le conteneur. Claude écrit du Python avec le sous-outil d'opérations sur les fichiers et l'exécute avec une commande Bash. Avec `code_execution_20260120` ou ultérieur et l'[appel d'outils programmatique](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/programmatic-tool-calling), l'état de l'interpréteur Python (comme les liaisons de variables) persiste également entre les requêtes qui réutilisent le conteneur.

### Quand Claude exécute du code

Claude exécute du code lorsque la requête bénéficie d'un calcul ou d'une manipulation de fichiers :

* Mathématiques non triviales (grands nombres, nombreuses étapes, résultats sensibles à la précision)
* Analyse de données, analyse de fichiers ou visualisation
* Exécution d'algorithmes ou simulation
* Demandes explicites d'« exécuter », de « calculer » ou de « lancer »

Claude répond directement sans exécuter de code pour :

* L'arithmétique simple et les faits mathématiques bien connus
* Les demandes factuelles, conversationnelles ou créatives
* Les conversions d'unités ou traductions simples

Si vous souhaitez que Claude exécute du code pour une demande limite, demandez-le explicitement (par exemple, « exécute du code pour vérifier cela »).

## Travailler avec des fichiers

### Téléverser et analyser vos propres fichiers

Pour analyser vos propres fichiers de données (tels que CSV, Excel ou images), téléversez-les via la Files API et référencez-les dans votre requête.

L'environnement Python peut traiter divers types de fichiers téléversés via la Files API, notamment :

* CSV
* Excel (.xlsx, .xls)
* JSON
* XML
* Images (JPEG, PNG, GIF, WebP)
* Fichiers texte (.txt, .md, .py et autres)

#### Téléverser et analyser des fichiers

1. **Téléversez votre fichier** à l'aide de la [Files API](https://platform.claude.com/docs/fr/build-with-claude/files)
2. **Référencez le fichier** dans votre message à l'aide d'un bloc de contenu `container_upload`
3. **Incluez l'outil d'exécution de code** dans votre requête API

<CodeGroup>
  ```bash cURL
  # Tout d'abord, téléversez un fichier et récupérez l'ID du fichier (avec jq).
  FILE_ID=$(curl --fail-with-body -sS https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -F "file=@data.csv" | jq -r '.id')

  # Utilisez ensuite le file_id avec l'exécution de code.
  curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": [
          {"type": "text", "text": "Analyze this CSV data"},
          {"type": "container_upload", "file_id": "'"$FILE_ID"'"}
        ]
      }],
      "tools": [{
        "type": "code_execution_20250825",
        "name": "code_execution"
      }]
    }'
  ```

  ```bash CLI
  # Commencez par téléverser un fichier et récupérer son ID.
  FILE_ID=$(ant files upload --file ./data.csv --transform id --raw-output)

  # Utilisez ensuite le file_id avec l'exécution de code.
  ant messages create <<YAML
  model: claude-opus-5-5
  max_tokens: 4096
  messages:
    - role: user
      content:
        - type: text
          text: Analyze this CSV data
        - type: container_upload
          file_id: $FILE_ID
  tools:
    - type: code_execution_20250825
      name: code_execution
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  # Téléverser un fichier
  file_object = client.files.upload(file=Path("data.csv"))

  # Utiliser le file_id avec l'exécution de code
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": [
                  {"type": "text", "text": "Analyze this CSV data"},
                  {"type": "container_upload", "file_id": file_object.id},
              ],
          }
      ],
      tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
  )

  print(response.to_json())
  ```

  ```typescript TypeScript
  import { createReadStream } from "node:fs";
  // ...
  const client = new Anthropic();

  // Téléverser un fichier
  const fileObject = await client.files.upload({
    file: createReadStream("data.csv")
  });

  // Utiliser le file_id avec l'exécution de code
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: "Analyze this CSV data" },
          { type: "container_upload", file_id: fileObject.id }
        ]
      }
    ],
    tools: [
      {
        type: "code_execution_20250825",
        name: "code_execution"
      }
    ]
  });

  console.log(JSON.stringify(response));
  ```

  ```csharp C#
  AnthropicClient client = new();

  // Téléverser un fichier
  var fileObject = await client.Files.Upload(new FileUploadParams
  {
      File = File.OpenRead("data.csv")
  });

  // Utiliser le file_id avec l'exécution de code
  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new()
          {
              Role = Role.User,
              Content = new([
                  new TextBlockParam { Text = "Analyze this CSV data" },
                  new ContainerUploadBlockParam { FileID = fileObject.ID }
              ])
          }
      ],
      Tools = [new CodeExecutionTool20250825()]
  };

  var response = await client.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  ctx := context.Background()
  client := anthropic.NewClient()

  // Téléverser un fichier.
  file, err := os.Open("data.csv")
  if err != nil {
  	log.Fatal(err)
  }
  defer file.Close()

  fileObject, err := client.Files.Upload(ctx, anthropic.FileUploadParams{
  	File: file,
  })
  if err != nil {
  	log.Fatal(err)
  }

  // Utiliser le file_id avec l'exécution de code.
  response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(
  			anthropic.NewTextBlock("Analyze this CSV data"),
  			anthropic.NewContainerUploadBlock(fileObject.ID),
  		),
  	},
  	Tools: []anthropic.ToolUnionParam{
  		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(response.RawJSON())
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Téléverser un fichier
  FileMetadata fileObject = client.files().upload(
      FileUploadParams.builder()
          .file(Path.of("data.csv"))
          .build()
  );

  // Utiliser le file_id avec l'exécution de code
  Message response = client.messages().create(
      MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessageOfBlockParams(List.of(
              ContentBlockParam.ofText(TextBlockParam.builder()
                  .text("Analyze this CSV data")
                  .build()),
              ContentBlockParam.ofContainerUpload(ContainerUploadBlockParam.builder()
                  .fileId(fileObject.id())
                  .build())
          ))
          .addTool(CodeExecutionTool20250825.builder().build())
          .build()
  );

  IO.println(ObjectMappers.jsonMapper().valueToTree(response));
  ```

  ```php PHP
  $client = new Client();

  // Téléverser un fichier
  $fileObject = $client->files->upload(
      file: FileParam::fromResource(fopen('data.csv', 'r')),
  );

  // Utiliser le file_id avec l'exécution de code
  $response = $client->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      maxTokens: 4096,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  TextBlockParam::with(text: 'Analyze this CSV data'),
                  ContainerUploadBlockParam::with(fileID: $fileObject->id),
              ],
          ],
      ],
      tools: [new CodeExecutionTool20250825()],
  );

  echo json_encode($response), PHP_EOL;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  # Téléverser un fichier
  file_object = client.files.upload(
    file: Pathname("data.csv")
  )

  # Utiliser le file_id avec l'exécution de code
  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: "Analyze this CSV data" },
          { type: "container_upload", file_id: file_object.id }
        ]
      }
    ],
    tools: [
      Anthropic::CodeExecutionTool20250825.new
    ]
  )

  puts response.to_json
  ```
</CodeGroup>

### Récupérer les fichiers générés

Lorsque Claude enregistre des fichiers dans son répertoire de sortie pendant l'exécution de code (voir [Comment les fichiers générés sont capturés](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#how-generated-files-are-captured)), l'ID de chaque fichier apparaît dans le résultat de l'outil d'exécution de code, et vous pouvez le télécharger avec la [Files API](https://platform.claude.com/docs/fr/build-with-claude/files) :

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Télécharger chaque fichier généré nécessite une boucle sur les ID de fichiers dans le résultat de l'outil, ce qui demande plus de logique qu'une seule commande shell. Utilisez le [SDK Claude](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) pour cela.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Télécharger chaque fichier généré nécessite une boucle sur les ID de fichiers dans le résultat de l'outil, ce qui demande plus de logique qu'une seule commande shell. Utilisez le [SDK Claude](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) pour cela.
  </CodeGroupItem>

  ```python Python
  client = Anthropic()

  # Demander une exécution de code qui crée des fichiers
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Create a matplotlib visualization and save it as output.png",
          }
      ],
      tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
  )


  # Extraire les ID de fichiers de la réponse
  def extract_file_ids(response: Message) -> list[str]:
      file_ids: list[str] = []
      for item in response.content:
          if item.type == "bash_code_execution_tool_result":
              content_item = item.content
              if content_item.type == "bash_code_execution_result":
                  for output_block in content_item.content:
                      file_ids.append(output_block.file_id)
      return file_ids


  # Télécharger les fichiers créés
  for file_id in extract_file_ids(response):
      file_metadata = client.files.retrieve_metadata(file_id)
      file_content = client.files.download(file_id)
      file_content.write_to_file(file_metadata.filename)
      print(f"Downloaded: {file_metadata.filename}")
  ```

  ```typescript TypeScript
  import { writeFile } from "node:fs/promises";

  const client = new Anthropic();

  // Demander une exécution de code qui crée des fichiers.
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Create a matplotlib visualization and save it as output.png"
      }
    ],
    tools: [
      {
        type: "code_execution_20250825",
        name: "code_execution"
      }
    ]
  });

  // Extraire les ID de fichiers de la réponse et télécharger chaque fichier créé.
  for (const block of response.content) {
    if (block.type === "bash_code_execution_tool_result") {
      const result = block.content;
      if (result.type === "bash_code_execution_result") {
        for (const outputBlock of result.content) {
          const [fileMetadata, fileResponse] = await Promise.all([
            client.files.retrieveMetadata(outputBlock.file_id),
            client.files.download(outputBlock.file_id)
          ]);
          await writeFile(fileMetadata.filename, await fileResponse.bytes());
          console.log(`Downloaded: ${fileMetadata.filename}`);
        }
      }
    }
  }
  ```

  ```csharp C#
  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [new() { Role = Role.User, Content = "Create a matplotlib visualization and save it as output.png" }],
      Tools = [new CodeExecutionTool20250825()]
  };

  var response = await client.Messages.Create(parameters);

  // Collecter les ID de fichiers à partir des résultats d'outils
  List<string> fileIds = [];
  foreach (var block in response.Content)
  {
      if (!block.TryPickBashCodeExecutionToolResult(out var toolResult))
          continue;
      if (!toolResult.Content.TryPickBashCodeExecutionResultBlock(out var result))
          continue;
      foreach (var output in result.Content)
      {
          fileIds.Add(output.FileID);
      }
  }

  // Télécharger chaque fichier créé
  foreach (var fileId in fileIds)
  {
      var fileMetadata = await client.Files.RetrieveMetadata(fileId);
      using var download = await client.Files.Download(fileId);
      var downloadStream = await download.ReadAsStream();
      await using var target = File.Create(fileMetadata.Filename);
      await downloadStream.CopyToAsync(target);
      Console.WriteLine($"Downloaded: {fileMetadata.Filename}");
  }
  ```

  ```go Go
  	client := anthropic.NewClient()
  	ctx := context.Background()

  	response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 4096,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Create a matplotlib visualization and save it as output.png")),
  		},
  		Tools: []anthropic.ToolUnionParam{
  			{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
  		},
  	})
  	if err != nil {
  		log.Fatal(err)
  	}

  	fileIDs := extractFileIDs(response)

  	for _, fileID := range fileIDs {
  		fileMetadata, err := client.Files.GetMetadata(ctx, fileID, anthropic.FileGetMetadataParams{})
  		if err != nil {
  			log.Fatal(err)
  		}

  		fileContent, err := client.Files.Download(ctx, fileID, anthropic.FileDownloadParams{})
  		if err != nil {
  			log.Fatal(err)
  		}

  		outFile, err := os.Create(fileMetadata.Filename)
  		if err != nil {
  			log.Fatal(err)
  		}

  		_, err = io.Copy(outFile, fileContent.Body)
  		if err != nil {
  			log.Fatal(err)
  		}
  		outFile.Close()
  		fileContent.Body.Close()

  		fmt.Printf("Downloaded: %s\n", fileMetadata.Filename)
  	}
  // ...

  func extractFileIDs(response *anthropic.Message) []string {
  	var fileIDs []string
  	for _, item := range response.Content {
  		switch variant := item.AsAny().(type) {
  		case anthropic.BashCodeExecutionToolResultBlock:
  			// Récupérer les ID de fichiers à partir du résultat de l'outil.
  			for _, file := range variant.Content.Content {
  				if file.FileID != "" {
  					fileIDs = append(fileIDs, file.FileID)
  				}
  			}
  		}
  	}
  	return fileIDs
  }
  ```

  ```java Java
  void main() throws Exception {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Create a matplotlib visualization and save it as output.png")
          .addTool(CodeExecutionTool20250825.builder().build())
          .build();

      Message response = client.messages().create(params);

      List<String> fileIds = extractFileIds(response);

      for (String fileId : fileIds) {
          FileMetadata fileMetadata = client.files().retrieveMetadata(fileId);
          try (HttpResponse fileContent = client.files().download(fileId)) {
              Files.copy(
                  fileContent.body(),
                  Path.of(fileMetadata.filename()),
                  StandardCopyOption.REPLACE_EXISTING);
          }
          IO.println("Downloaded: " + fileMetadata.filename());
      }
  }

  List<String> extractFileIds(Message response) {
      List<String> fileIds = new ArrayList<>();
      // Collecter les ID de fichiers à partir des résultats d'outils.
      for (ContentBlock item : response.content()) {
          item.bashCodeExecutionToolResult().ifPresent(toolResult -> {
              if (toolResult.content().isBashCodeExecutionResultBlock()) {
                  BashCodeExecutionResultBlock result =
                      toolResult.content().asBashCodeExecutionResultBlock();
                  for (BashCodeExecutionOutputBlock output : result.content()) {
                      fileIds.add(output.fileId());
                  }
              }
          });
      }
      return fileIds;
  }
  ```

  ```php PHP
  $client = new Client();

  // Demander une exécution de code qui crée des fichiers
  $response = $client->messages->create(
      maxTokens: 4096,
      messages: [
          [
              'role' => 'user',
              'content' => 'Create a matplotlib visualization and save it as output.png',
          ],
      ],
      model: Model::CLAUDE_OPUS_5_5,
      tools: [new CodeExecutionTool20250825()],
  );

  /**
   * Extract file IDs from the response.
   *
   * @return list<string>
   */
  function extractFileIds(Message $response): array
  {
      $fileIds = [];
      foreach ($response->content as $block) {
          if ($block->type !== 'bash_code_execution_tool_result') {
              continue;
          }
          $resultBlock = $block->content;
          if ($resultBlock->type !== 'bash_code_execution_result') {
              continue;
          }
          foreach ($resultBlock->content as $outputBlock) {
              $fileIds[] = $outputBlock->fileID;
          }
      }
      return $fileIds;
  }

  // Télécharger les fichiers créés
  foreach (extractFileIds($response) as $fileId) {
      $fileMetadata = $client->files->retrieveMetadata($fileId);
      $fileContent = $client->files->download($fileId);

      file_put_contents($fileMetadata->filename, $fileContent);
      echo "Downloaded: {$fileMetadata->filename}\n";
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Create a matplotlib visualization and save it as output.png"
      }
    ],
    tools: [
      {
        type: "code_execution_20250825",
        name: "code_execution"
      }
    ]
  )

  def extract_file_ids(response)
    file_ids = []
    response.content.each do |item|
      if item.type == :bash_code_execution_tool_result
        # CONTOURNEMENT du bug de coercition d'union d'anthropic-sdk-ruby (SDK-636) : item.content est une
        # union de contenu imbriquée, donc les accesseurs typés sur `item.content` ne sont pas fiables.
        # Lisez plutôt les données brutes de la réponse via l'API publique `BaseModel#[]`.
        content_item = item.content
        if content_item[:type].to_s == "bash_code_execution_result"
          Array(content_item[:content]).each do |output_block|
            file_ids << output_block[:file_id]
          end
        end
      end
    end
    file_ids
  end

  extract_file_ids(response).each do |file_id|
    file_metadata = client.files.retrieve_metadata(file_id)
    file_content = client.files.download(file_id)

    File.open(file_metadata.filename, "wb") do |f|
      f.write(file_content.read)
    end

    puts "Downloaded: #{file_metadata.filename}"
  end
  ```
</CodeGroup>

#### Comment les fichiers générés sont capturés

Chaque appel `bash_code_execution` reçoit un nouveau répertoire vide, accessible à la commande sous le nom `$OUTPUT_DIR`. Lorsque la commande se termine, les fichiers situés au niveau supérieur de ce répertoire sont capturés et renvoyés sous forme d'entrées `file_id` dans la liste `content` du résultat. Les fichiers écrits ailleurs restent dans le conteneur et ne sont pas renvoyés.

La description de l'outil indique à Claude de partager les fichiers en les copiant dans `$OUTPUT_DIR`. Si votre application dépend de la réception d'un fichier, demandez à Claude de le copier dans `$OUTPUT_DIR` et de lister le répertoire dans la même commande, afin que la sortie de `ls` confirme la capture (Claude ne voit pas la liste `content`) :

```bash
python /tmp/make_report.py && cp /tmp/report.pdf "$OUTPUT_DIR/" && ls "$OUTPUT_DIR"
```

Un fichier que Claude a écrit ailleurs se trouve toujours dans le conteneur, vous pouvez donc [réutiliser le conteneur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#container-reuse) et demander à Claude de le copier dans `$OUTPUT_DIR`.

### Content Credentials sur les fichiers générés

Sur la Claude API, les fichiers image, vidéo et audio pris en charge que Claude produit dans le sandbox d'exécution de code portent des Content Credentials [C2PA](https://c2pa.org/) lorsque vous les téléchargez via la [Files API](https://platform.claude.com/docs/fr/build-with-claude/files). Les [formats pris en charge](https://opensource.contentauthenticity.org/docs/sdk-repos/c2pa-python/docs/supported-formats/) incluent PNG, JPEG, GIF, WebP, TIFF, HEIC, AVIF, SVG, MP4, MOV, MP3, WAV, FLAC et M4A. Le credential est un manifeste signé cryptographiquement et intégré dans les métadonnées du fichier. Il identifie Anthropic comme émetteur, comporte un horodatage et enregistre la description d'action « Claude provided this file at the request of a user and may have created or modified the file contents. »

La signature ne nécessite aucune modification de vos requêtes ni de votre traitement des réponses, et le manifeste n'enregistre rien sur vous, votre organisation ou votre requête. Le contenu visible du fichier est inchangé. Le manifeste ajoute quelques kilo-octets, de sorte que la taille et la somme de contrôle du fichier téléchargé diffèrent de celles du fichier tel qu'il existe à l'intérieur du conteneur. Les fichiers texte, les PDF et les documents bureautiques ne sont pas signés car ce ne sont pas des formats pris en charge pour la signature. Les fichiers que vous téléversez sont stockés tels quels, y compris les Content Credentials qu'ils portent déjà.

Pour vérifier un identifiant, inspectez le fichier avec n'importe quel outil compatible C2PA, tel que l'[utilitaire en ligne de commande c2patool](https://github.com/contentauth/c2pa-rs) open source. Le réencodage, la conversion de format, les captures d'écran et les outils qui suppriment les métadonnées retirent l'identifiant, de sorte qu'un identifiant manquant ne signifie pas qu'un fichier n'a pas été produit avec Claude. Pour en savoir plus sur les raisons pour lesquelles un identifiant peut être absent, consultez [Comment Claude marque le contenu généré par IA](https://support.claude.com/en/articles/16266773-how-claude-marks-ai-generated-content).

## Définition de l'outil

L'outil d'exécution de code ne nécessite aucun paramètre supplémentaire :

```json JSON
{
  "type": "code_execution_20250825",
  "name": "code_execution"
}
```

Les deux champs sont fixes : `type` sélectionne la version de l'outil, et `name` doit être `code_execution`.

Lorsque vous fournissez cet outil, Claude obtient automatiquement l'accès à deux sous-outils :

* `bash_code_execution` : exécuter des commandes shell
* `text_editor_code_execution` : afficher, créer et modifier des fichiers, y compris écrire du code

Lorsque Claude exécute du code, la réponse inclut également un objet `container` de niveau supérieur avec l'`id` du conteneur et l'horodatage `expires_at`. Retransmettez cet ID dans le paramètre de requête de niveau supérieur `container` pour continuer à utiliser le même conteneur. Voir [Réutilisation des conteneurs](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#container-reuse).

## Format de réponse

L'outil d'exécution de code peut renvoyer deux types de résultats selon l'opération :

### Réponse de commande Bash

```json Output
{
  "type": "server_tool_use",
  "id": "srvtoolu_01B3C4D5E6F7G8H9I0J1K2L3",
  "name": "bash_code_execution",
  "input": {
    "command": "ls -la | head -5"
  }
},
{
  "type": "bash_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01B3C4D5E6F7G8H9I0J1K2L3",
  "content": {
    "type": "bash_code_execution_result",
    "stdout": "total 24\ndrwxr-xr-x 2 user user 4096 Jan 1 12:00 .\ndrwxr-xr-x 3 user user 4096 Jan 1 11:00 ..\n-rw-r--r-- 1 user user  220 Jan 1 12:00 data.csv\n-rw-r--r-- 1 user user  180 Jan 1 12:00 config.json",
    "stderr": "",
    "return_code": 0,
    "content": []
  }
}
```

### Réponses d'opérations sur les fichiers

**Afficher un fichier :**

```json Output
{
  "type": "server_tool_use",
  "id": "srvtoolu_01C4D5E6F7G8H9I0J1K2L3M4",
  "name": "text_editor_code_execution",
  "input": {
    "command": "view",
    "path": "config.json"
  }
},
{
  "type": "text_editor_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01C4D5E6F7G8H9I0J1K2L3M4",
  "content": {
    "type": "text_editor_code_execution_view_result",
    "file_type": "text",
    "content": "{\n  \"setting\": \"value\",\n  \"debug\": true\n}",
    "num_lines": 4,
    "start_line": 1,
    "total_lines": 4
  }
}
```

**Créer un fichier :**

```json Output
{
  "type": "server_tool_use",
  "id": "srvtoolu_01D5E6F7G8H9I0J1K2L3M4N5",
  "name": "text_editor_code_execution",
  "input": {
    "command": "create",
    "path": "new_file.txt",
    "file_text": "Hello, World!"
  }
},
{
  "type": "text_editor_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01D5E6F7G8H9I0J1K2L3M4N5",
  "content": {
    "type": "text_editor_code_execution_create_result",
    "is_file_update": false
  }
}
```

**Modifier un fichier (str\_replace) :**

```json Output
{
  "type": "server_tool_use",
  "id": "srvtoolu_01E6F7G8H9I0J1K2L3M4N5O6",
  "name": "text_editor_code_execution",
  "input": {
    "command": "str_replace",
    "path": "config.json",
    "old_str": "\"debug\": true",
    "new_str": "\"debug\": false"
  }
},
{
  "type": "text_editor_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01E6F7G8H9I0J1K2L3M4N5O6",
  "content": {
    "type": "text_editor_code_execution_str_replace_result",
    "old_start": 3,
    "old_lines": 1,
    "new_start": 3,
    "new_lines": 1,
    "lines": ["-  \"debug\": true", "+  \"debug\": false"]
  }
}
```

### Résultats

Les résultats de commandes Bash (`bash_code_execution_result`) incluent :

* `stdout` : sortie d'une exécution réussie
* `stderr` : messages d'erreur si l'exécution échoue
* `return_code` : 0 en cas de succès, non nul en cas d'échec
* `content` : une liste avec une entrée pour chaque fichier que la commande a laissé dans `$OUTPUT_DIR` (voir [Comment les fichiers générés sont capturés](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#how-generated-files-are-captured)). Chaque entrée porte le `file_id` permettant de [récupérer le fichier](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#retrieve-generated-files) avec la Files API

Les résultats d'opérations sur les fichiers ont leurs propres champs :

* **Afficher** (`text_editor_code_execution_view_result`) : `file_type`, `content`, `num_lines`, `start_line`, `total_lines`
* **Créer** (`text_editor_code_execution_create_result`) : `is_file_update` (indique si le fichier existait déjà)
* **Modifier** (`text_editor_code_execution_str_replace_result`) : `old_start`, `old_lines`, `new_start`, `new_lines`, `lines` (format diff)

### Erreurs

Chaque type d'outil peut renvoyer des erreurs spécifiques :

**Erreurs communes (tous les outils) :**

```json Output
{
  "type": "bash_code_execution_tool_result",
  "tool_use_id": "srvtoolu_01VfmxgZ46TiHbmXgy928hQR",
  "content": {
    "type": "bash_code_execution_tool_result_error",
    "error_code": "unavailable"
  }
}
```

**Codes d'erreur par type d'outil :**

| Outil           | Code d'erreur             | Description                                                            |
| --------------- | ------------------------- | ---------------------------------------------------------------------- |
| Tous les outils | `unavailable`             | L'outil est temporairement indisponible                                |
| Tous les outils | `execution_time_exceeded` | L'invocation de l'outil a dépassé le temps d'exécution maximal         |
| Tous les outils | `invalid_tool_input`      | Paramètres non valides fournis à l'outil                               |
| Tous les outils | `too_many_requests`       | Limite de débit dépassée pour l'utilisation de l'outil                 |
| bash            | `output_file_too_large`   | La sortie de la commande a dépassé la taille maximale                  |
| text\_editor    | `file_not_found`          | Le fichier n'existe pas (pour les opérations d'affichage/modification) |

Un conteneur expiré ne peut pas être réutilisé : les requêtes qui y font référence renvoient une erreur au lieu de le restaurer. Renvoyez la requête sans le paramètre `container` pour obtenir un nouveau conteneur.

### Raison d'arrêt `pause_turn`

La réponse peut inclure une raison d'arrêt `pause_turn`, qui indique que l'API a mis en pause un tour de longue durée. Vous pouvez renvoyer la réponse telle quelle dans une requête ultérieure pour laisser Claude poursuivre son tour, ou modifier le contenu si vous souhaitez interrompre la conversation.

## Conteneurs

L'outil d'exécution de code s'exécute dans un environnement conteneurisé sécurisé, conçu spécifiquement pour l'exécution de code, avec un accent particulier sur Python.

### Environnement d'exécution

* **Version de Python :** 3.11
* **Système d'exploitation :** conteneur basé sur Linux
* **Architecture :** x86\_64 (AMD64)

### Limites de ressources

* **Mémoire :** 5 Gio de RAM
* **Espace disque :** 5 Gio de stockage d'espace de travail
* **CPU :** 1 CPU
* **Temps d'exécution :** une invocation d'outil qui dépasse le temps d'exécution maximal renvoie une [erreur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#errors) `execution_time_exceeded`. Avec l'[appel d'outils programmatique](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/programmatic-tool-calling), chaque cellule REPL a également une limite de 90 secondes de temps réel

### Réseau et sécurité

* **Accès à Internet :** entièrement désactivé pour des raisons de sécurité
* **Connexions externes :** aucune requête réseau sortante autorisée
* **Isolation de la sandbox :** isolation complète du système hôte et des autres conteneurs
* **Accès aux fichiers :** limité au répertoire de l'espace de travail uniquement
* **Portée de l'espace de travail :** comme la [Files API](https://platform.claude.com/docs/fr/build-with-claude/files), les conteneurs sont limités à l'espace de travail de la requête
* **Expiration :** les conteneurs expirent 30 jours après leur création

### Bibliothèques préinstallées

L'environnement Python en sandbox inclut ces bibliothèques couramment utilisées :

* **Science des données :** pandas, numpy, scipy, scikit-learn, statsmodels
* **Visualisation :** matplotlib, seaborn
* **Traitement de fichiers :** pyarrow, openpyxl, xlsxwriter, xlrd, pillow, python-pptx, python-docx, pypdf, pdfplumber, pypdfium2, pdf2image, pdfkit, tabula-py, reportlab\[pycairo], Img2pdf
* **Mathématiques et calcul :** sympy, mpmath
* **Utilitaires :** tqdm, python-dateutil, pytz, joblib

Le conteneur inclut également des outils en ligne de commande tels que unzip, unrar, 7zip, bc, rg (ripgrep), fd et sqlite.

Le conteneur n'a pas d'accès à Internet, Claude ne peut donc pas télécharger ni installer de paquets supplémentaires à l'exécution : seules les bibliothèques préinstallées sont disponibles.

## Réutilisation des conteneurs

Vous pouvez réutiliser un conteneur existant sur plusieurs requêtes API en fournissant l'ID de conteneur d'une réponse précédente. Cela vous permet de conserver les fichiers créés entre les requêtes. Avec `code_execution_20260120` ou ultérieur et l'[appel d'outils programmatique](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/programmatic-tool-calling), l'état de l'interpréteur Python persiste également.

Les conteneurs expirent 30 jours après leur création. Après environ 5 minutes d'inactivité, un conteneur fait l'objet d'un point de contrôle, et l'envoi d'une requête avec son ID dans la fenêtre de 30 jours le restaure. L'horodatage `expires_at` dans l'objet `container` de la réponse est une valeur glissante plus courte et n'indique pas la limite de 30 jours. Un conteneur qui a expiré ne peut pas être réutilisé. Renvoyez la requête sans le paramètre `container` pour obtenir un nouveau conteneur.

### Exemple

<CodeGroup>
  ```bash cURL
  # Première requête : créer un fichier contenant un nombre aléatoire et récupérer l'ID du conteneur (avec jq).
  CONTAINER_ID=$(curl -s https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": "Write a file with a random number and save it to \"/tmp/number.txt\""
      }],
      "tools": [{
        "type": "code_execution_20250825",
        "name": "code_execution"
      }]
    }' | jq -r '.container.id')

  # Deuxième requête : réutiliser le conteneur pour lire le fichier.
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "container": "'"$CONTAINER_ID"'",
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": "Read the number from \"/tmp/number.txt\" and calculate its square"
      }],
      "tools": [{
        "type": "code_execution_20250825",
        "name": "code_execution"
      }]
    }'
  ```

  ```bash CLI
  # Première requête : créer un fichier contenant un nombre aléatoire.
  CONTAINER_ID=$(ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 4096 \
    --message '{role: user, content: Write a file with a random number and save it to "/tmp/number.txt"}' \
    --tool '{type: code_execution_20250825, name: code_execution}' \
    --transform container.id --raw-output)

  # Deuxième requête : réutiliser le conteneur pour lire le fichier.
  ant messages create \
    --container "$CONTAINER_ID" \
    --model claude-opus-5-5 \
    --max-tokens 4096 \
    --message '{role: user, content: Read the number from "/tmp/number.txt" and calculate its square}' \
    --tool '{type: code_execution_20250825, name: code_execution}'
  ```

  ```python Python
  client = anthropic.Anthropic()

  # Première requête : créer un fichier contenant un nombre aléatoire dans un nouveau conteneur.
  response1 = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Write a file with a random number and save it to '/tmp/number.txt'",
          }
      ],
      tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
  )

  # Deuxième requête : renvoyer l'ID du conteneur pour que Claude réutilise le même conteneur.
  response2 = client.messages.create(
      container=response1.container.id,
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Read the number from '/tmp/number.txt' and calculate its square",
          }
      ],
      tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
  )

  print(response2.to_json())
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  // Première requête : Claude crée un fichier dans un nouveau conteneur d'exécution de code.
  const response1 = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Write a file with a random number and save it to '/tmp/number.txt'"
      }
    ],
    tools: [{ type: "code_execution_20250825", name: "code_execution" }]
  });

  // La réponse inclut le conteneur une fois l'outil d'exécution de code exécuté.
  if (!response1.container) {
    throw new Error("Expected the first response to include a container");
  }

  // Seconde requête : renvoyez l'ID du conteneur afin de réutiliser le même conteneur.
  const response2 = await client.messages.create({
    container: response1.container.id,
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Read the number from /tmp/number.txt and calculate its square" }
    ],
    tools: [{ type: "code_execution_20250825", name: "code_execution" }]
  });

  console.log(JSON.stringify(response2));
  ```

  ```csharp C#
  AnthropicClient client = new();

  // Première requête : Claude crée un fichier dans un nouveau conteneur d'exécution de code.
  var response1 = await client.Messages.Create(new()
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [new() { Role = Role.User, Content = "Write a file with a random number and save it to '/tmp/number.txt'" }],
      Tools = [new CodeExecutionTool20250825()]
  });

  // Deuxième requête : renvoyez l'ID du conteneur pour que Claude réutilise le même conteneur.
  var response2 = await client.Messages.Create(new()
  {
      Container = response1.Container!.ID,
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [new() { Role = Role.User, Content = "Read the number from '/tmp/number.txt' and calculate its square" }],
      Tools = [new CodeExecutionTool20250825()]
  });

  Console.WriteLine(response2);
  ```

  ```go Go
  client := anthropic.NewClient()
  ctx := context.Background()

  codeExecution := []anthropic.ToolUnionParam{
  	{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
  }

  // Première requête : créer un fichier contenant un nombre aléatoire dans un nouveau conteneur.
  response1, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Write a file with a random number and save it to '/tmp/number.txt'")),
  	},
  	Tools: codeExecution,
  })
  if err != nil {
  	log.Fatal(err)
  }

  // Réutiliser le conteneur de la première requête afin que le fichier soit toujours présent.
  response2, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  	Container: anthropic.MessageCreateParamsContainerUnion{
  		OfString: anthropic.String(response1.Container.ID),
  	},
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Read the number from '/tmp/number.txt' and calculate its square")),
  	},
  	Tools: codeExecution,
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(response2.RawJSON())
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Première requête : créer un fichier contenant un nombre aléatoire dans un nouveau conteneur.
  MessageCreateParams params1 = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(4096L)
      .addUserMessage("Write a file with a random number and save it to '/tmp/number.txt'")
      .addTool(CodeExecutionTool20250825.builder().build())
      .build();

  Message response1 = client.messages().create(params1);

  // Deuxième requête : renvoyer l'ID du conteneur afin de réutiliser le même conteneur.
  MessageCreateParams params2 = MessageCreateParams.builder()
      .container(response1.container().orElseThrow().id())
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(4096L)
      .addUserMessage("Read the number from '/tmp/number.txt' and calculate its square")
      .addTool(CodeExecutionTool20250825.builder().build())
      .build();

  Message response2 = client.messages().create(params2);
  IO.println(ObjectMappers.jsonMapper().valueToTree(response2));
  ```

  ```php PHP
  $client = new Client();

  // Première requête : Claude écrit le fichier dans un nouveau conteneur d'exécution de code.
  $response1 = $client->messages->create(
      maxTokens: 4096,
      messages: [
          [
              'role' => 'user',
              'content' => "Write a file with a random number and save it to '/tmp/number.txt'",
          ],
      ],
      model: Model::CLAUDE_OPUS_5_5,
      tools: [new CodeExecutionTool20250825()],
  );

  // Deuxième requête : réutilisez le conteneur pour que '/tmp/number.txt' soit toujours présent.
  $response2 = $client->messages->create(
      container: $response1->container->id,
      maxTokens: 4096,
      messages: [
          [
              'role' => 'user',
              'content' => "Read the number from '/tmp/number.txt' and calculate its square",
          ],
      ],
      model: Model::CLAUDE_OPUS_5_5,
      tools: [new CodeExecutionTool20250825()],
  );

  echo json_encode($response2), PHP_EOL;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  # Première requête : Claude crée le fichier dans un nouveau conteneur d'exécution de code.
  response1 = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Write a file with a random number and save it to '/tmp/number.txt'"
      }
    ],
    tools: [Anthropic::CodeExecutionTool20250825.new]
  )

  # Deuxième requête : renvoyez l'ID du conteneur pour que Claude réutilise le même conteneur.
  response2 = client.messages.create(
    container: response1.container.id,
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Read the number from '/tmp/number.txt' and calculate its square"
      }
    ],
    tools: [Anthropic::CodeExecutionTool20250825.new]
  )

  puts response2.to_json
  ```
</CodeGroup>

## Utiliser l'exécution de code avec d'autres outils d'exécution

Lorsque vous fournissez l'exécution de code en parallèle d'outils fournis par le client qui exécutent également du code (comme un [outil Bash](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/bash-tool) ou un REPL personnalisé), Claude opère dans un environnement multi-ordinateurs. L'outil d'exécution de code s'exécute dans le conteneur sandbox d'Anthropic, tandis que vos outils fournis par le client s'exécutent dans un environnement distinct que vous contrôlez. Claude peut parfois confondre ces environnements, en tentant d'utiliser le mauvais outil ou en supposant que l'état est partagé entre eux.

Pour éviter cela, ajoutez à votre invite système des instructions qui clarifient la distinction :

```text wrap
When multiple code execution environments are available, be aware that:
- Variables, files, and state do NOT persist between different execution environments
- Use the code_execution tool for general-purpose computation in Anthropic's sandboxed environment
- Use client-provided execution tools (e.g., bash) when you need access to the user's local system, files, or data
- If you need to pass results between environments, explicitly include outputs in subsequent tool calls rather than assuming shared state
```

Ceci est particulièrement important lorsque vous combinez l'exécution de code avec la [recherche web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool) ou la [récupération web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-fetch-tool), qui activent automatiquement l'exécution de code. Si votre application fournit déjà un outil shell côté client, l'exécution de code automatique crée un second environnement d'exécution que Claude doit distinguer.

Lorsque Claude appelle l'un de vos outils client en parallèle de l'exécution de code, l'API renvoie l'appel d'exécution de code sans son résultat. Le résultat arrive dans une réponse ultérieure, après que vous avez renvoyé les blocs `tool_result` pour vos outils client.

## Streaming

Avec le [streaming](https://platform.claude.com/docs/fr/build-with-claude/streaming) activé (`"stream": true`), vous recevrez les événements d'exécution de code au fur et à mesure qu'ils se produisent. L'entrée du sous-outil est diffusée sous forme d'événements `input_json_delta`, et chaque bloc de résultat arrive en entier dans un seul événement `content_block_start` :

```sse
event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "server_tool_use", "id": "srvtoolu_xyz789", "name": "bash_code_execution"}}

// Tool input streamed as partial JSON
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "input_json_delta", "partial_json": "{\"command\": \"python analyze.py\"}"}}

// Pause while the command runs

// Execution result delivered as a complete block
event: content_block_start
data: {"type": "content_block_start", "index": 2, "content_block": {"type": "bash_code_execution_tool_result", "tool_use_id": "srvtoolu_xyz789", "content": {"type": "bash_code_execution_result", "stdout": "   A  B  C\n0  1  2  3\n1  4  5  6", "stderr": "", "return_code": 0, "content": []}}}
```

## Requêtes par lots

Vous pouvez inclure l'outil d'exécution de code dans l'[API Messages Batches](https://platform.claude.com/docs/fr/build-with-claude/batch-processing). Les appels à l'outil d'exécution de code via l'API Messages Batches sont facturés au même tarif que ceux des requêtes classiques de l'API Messages.

## Utilisation et tarification

**L'exécution de code est gratuite lorsqu'elle est utilisée avec la recherche web ou la récupération web.** Lorsque `web_search_20260209` (ou une version ultérieure) ou `web_fetch_20260209` (ou une version ultérieure) est inclus dans votre requête API, aucun frais supplémentaire n'est facturé pour les appels à l'outil d'exécution de code au-delà des coûts standard des tokens d'entrée et de sortie.

Lorsqu'elle est utilisée sans ces outils, l'exécution de code est facturée selon le temps d'exécution, suivi séparément de l'utilisation des tokens :

* Le temps d'exécution est d'un minimum de 5 minutes.
* Chaque organisation reçoit **1 550 heures gratuites** d'utilisation par mois.
* L'utilisation supplémentaire au-delà de 1 550 heures est facturée à **0,05 $ USD par heure, par conteneur**.
* Si des fichiers sont inclus dans la requête, le temps d'exécution est facturé même si l'outil n'est pas appelé, car les fichiers sont préchargés dans le conteneur.

L'utilisation de l'exécution de code est suivie dans la réponse :

```json
{
  "usage": {
    "input_tokens": 105,
    "output_tokens": 239,
    "server_tool_use": {
      "code_execution_requests": 1
    }
  }
}
```

## Mettre à niveau vers la dernière version de l'outil

La dernière version de l'outil est `code_execution_20260521`. Pour passer d'une des trois versions actuelles à une autre, mettez à jour la chaîne `type` dans votre requête : les trois renvoient les blocs de réponse documentés dans [Format de réponse](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#response-format). Consultez [Versions de l'outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#tool-versions) pour savoir ce que chaque version ajoute et [Compatibilité](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#compatibility) pour les modèles qui les prennent en charge.

Le reste de cette section couvre la migration depuis l'ancienne version `code_execution_20250522`, limitée à Python, vers les versions actuelles de l'outil.

### Ce qui a changé

| Composant        | Ancienne version            | Version actuelle                                                    |
| ---------------- | --------------------------- | ------------------------------------------------------------------- |
| En-tête bêta     | `code-execution-2025-05-22` | Aucun requis                                                        |
| Type d'outil     | `code_execution_20250522`   | `code_execution_20250825` ou ultérieur                              |
| Capacités        | Python uniquement           | Commandes Bash, opérations sur les fichiers                         |
| Types de réponse | `code_execution_result`     | `bash_code_execution_result`, `text_editor_code_execution_*_result` |

### Rétrocompatibilité

* Toute l'exécution de code Python existante continue de fonctionner exactement comme avant
* Aucune modification requise pour les flux de travail existants limités à Python

### Étapes de mise à niveau

Pour effectuer la mise à niveau, mettez à jour le type d'outil dans vos requêtes API :

```diff
- "type": "code_execution_20250522"
+ "type": "code_execution_20250825"
```

**Vérifiez le traitement des réponses** (si vous analysez les réponses par programmation) :

* L'API n'envoie plus les anciens blocs pour les réponses d'exécution Python
* À la place, l'API envoie de nouveaux types de réponse pour les opérations Bash et sur fichiers (voir [Format de réponse](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#response-format))

## Conservation des données

L'exécution de code s'effectue dans des conteneurs sandbox côté serveur. Les données des conteneurs, y compris les artefacts d'exécution, les fichiers téléversés et les sorties, sont conservées jusqu'à 30 jours. Cette conservation s'applique à toutes les données traitées dans l'environnement du conteneur. Les fichiers que l'exécution de code crée dans la [Files API](https://platform.claude.com/docs/fr/build-with-claude/files) (récupérables avec `client.files.download()` (csharp, go: `client.Files.Download()`; java: `client.files().download()`; php: `$client->files->download()`)) persistent jusqu'à leur suppression explicite.

Pour l'éligibilité ZDR de toutes les fonctionnalités, consultez [API et conservation des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention).

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Outil conseiller" icon="compass" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/advisor-tool">
    Associez un modèle exécuteur plus rapide à un modèle conseiller plus intelligent qui fournit des orientations stratégiques en cours de génération.
  </Card>

  <Card title="Appel d'outils programmatique" icon="code" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/programmatic-tool-calling">
    Appelez vos propres outils depuis du code qui s'exécute à l'intérieur du conteneur d'exécution de code.
  </Card>

  <Card title="Files API" icon="file" href="https://platform.claude.com/docs/fr/build-with-claude/files">
    Téléversez des fichiers pour analyse et téléchargez les fichiers créés par l'exécution de code.
  </Card>

  <Card title="Utiliser les Agent Skills avec l'API" icon="book" href="https://platform.claude.com/docs/fr/build-with-claude/skills-guide">
    Découvrez comment utiliser les Agent Skills pour étendre les capacités de Claude via l'API.
  </Card>
</CardGroup>