---
title: Code-Ausführungstool
url: https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool
description: Führe Python- und Bash-Code in einem Sandbox-Container aus, um Daten zu analysieren, Dateien zu generieren und Lösungen iterativ zu verbessern.
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: Auf [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) erfordert die Code-Ausführung ein [Hosted on Anthropic-Deployment](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure).
details:
- Jedes unterstützte Modell akzeptiert alle drei [Tool-Versionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#tool-versions). Auf Claude Haiku 4.5 sind programmatisches Tool-Calling und REPL-Zustandspersistenz nicht verfügbar, daher verhalten sich die neueren Versionen dort wie `code_execution_20250825`.
- Für [Claude Mythos Preview](https://anthropic.com/glasswing) wird die Code-Ausführung auf der Claude API und Microsoft Foundry unterstützt.
---
Claude kann Daten analysieren, Visualisierungen erstellen, komplexe Berechnungen durchführen, Systembefehle ausführen, Dateien erstellen und bearbeiten sowie hochgeladene Dateien direkt innerhalb der API-Konversation verarbeiten. Das „code execution tool“ (Code-Ausführungstool) ermöglicht es Claude, Bash-Befehle auszuführen und Dateien zu bearbeiten, einschließlich des Schreibens von Code, in einer sicheren Sandbox-Umgebung.
**Die Code-Ausführung ist kostenlos, wenn sie zusammen mit Web Search oder Web Fetch verwendet wird (`web_search_20260209`, `web_fetch_20260209` oder neuer).** Wenn eines dieser Tools in deiner Anfrage enthalten ist, fallen für die Code-Ausführung in dieser Anfrage über die Standard-Token-Kosten hinaus keine zusätzlichen Gebühren an. Dies umfasst sowohl die Code-Ausführung hinter der dynamischen Filterung als auch jeglichen Code, den Claude direkt ausführt. Die Standardpreise für die Code-Ausführung gelten, wenn diese Tools nicht enthalten sind.
Die Code-Ausführung treibt auch die dynamische Filterung in den Tools [Web Search](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool) und [Web Fetch](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool) an: Claude filtert Ergebnisse innerhalb der Code-Ausführungsumgebung, bevor sie das „context window“ (Kontextfenster) erreichen. Wenn die dynamische Filterung läuft, stellt die API die dafür benötigte Code-Ausführung für die Anfrage automatisch bereit, sodass du das Code-Ausführungstool dafür nicht zu deiner Anfrage hinzufügen musst.
Nutze das [Feedback-Formular](https://forms.gle/LTAU6Xn2puCJMi1n6), um dein Feedback zu dieser Funktion zu teilen.
## Tool-Versionen
Das Code-Ausführungstool hat drei aktuelle Versionen, und jedes [unterstützte Modell](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#compatibility) akzeptiert alle drei. Jede Version baut auf der vorherigen auf:
* `code_execution_20250825` unterstützt Bash-Befehle und Dateioperationen.
* `code_execution_20260120` fügt REPL-Zustandspersistenz und [programmatisches Tool-Calling](https://platform.claude.com/docs/de/agents-and-tools/tool-use/programmatic-tool-calling) aus der Sandbox heraus hinzu. Claude Haiku 4.5 akzeptiert die Tool-Typen `code_execution_20260120` und `code_execution_20260521`, aber programmatisches Tool-Calling und die davon abhängige REPL-Zustandspersistenz sind dort nicht verfügbar, sodass sich die neueren Versionen dort wie `code_execution_20250825` verhalten.
* `code_execution_20260521` ist dieselbe Laufzeitumgebung wie `code_execution_20260120`. Der Unterschied besteht darin, dass die Tool-Beschreibung Claude über das 90-Sekunden-Wall-Clock-Limit für jede Python-Zelle beim programmatischen Tool-Calling informiert, sodass Claude lang laufende Zellen einplanen kann. Eine Zelle, die das Limit überschreitet, gibt ein normales Code-Ausführungsergebnis mit einem `return_code` ungleich null und einer `detection_timeout`-Statusmeldung in ihrer Ausgabe zurück. Dies ist getrennt vom [Fehlercode](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#errors) `execution_time_exceeded`, den die API zurückgibt, wenn ein gesamter Tool-Aufruf die maximale Ausführungszeit überschreitet.
Keine der drei Tool-Versionen erfordert einen `anthropic-beta`-Header. Die veralteten Beta-Header für die Code-Ausführung bleiben gültige Opt-ins.
Die Beispiele auf dieser Seite verwenden `code_execution_20250825`, das die gezeigten Bash- und Dateioperationen abdeckt und sich auf jedem unterstützten Modell gleich verhält; verwende `code_execution_20260120` oder neuer, wenn du programmatisches Tool-Calling oder REPL-Zustandspersistenz benötigst. Die aktuellen Tools [Web Search](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool) und [Web Fetch](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool) (`web_search_20260209`, `web_fetch_20260209` und neuer) erfordern `code_execution_20260120` oder neuer als ihre Code-Ausführungsversion.
Für ältere Tool-Versionen ist nicht garantiert, dass sie mit neueren Modellen kompatibel bleiben. Wenn du ein neues Modell einführst, prüfe [Tool-Versionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#tool-versions) und [Kompatibilität](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#compatibility) und bevorzuge die neueste Tool-Version, die deine Integration unterstützt.
Um zu prüfen, ob ein Modell das Code-Ausführungstool akzeptiert, bevor du eine Anfrage sendest, lies seinen Wert `capabilities.server_tools.code_execution.supported` aus der Models API aus. Verwende dafür nicht den Wert `capabilities.code_execution` auf oberster Ebene. Dieser gibt an, ob Code, der in diesem Tool läuft, die anderen Tools deiner Anfrage aufrufen kann, wie beim programmatischen Tool-Calling. [Die Models API verwenden](https://platform.claude.com/docs/de/models/overview#using-the-models-api) beschreibt beide Felder.
Wenn du noch das veraltete `code_execution_20250522` (nur Python) verwendest, siehe [Upgrade auf die neueste Tool-Version](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#upgrade-to-latest-tool-version), um davon zu migrieren.
## Schnellstart
Hier ist ein Beispiel, das Claude bittet, eine Berechnung durchzuführen:
```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
```
Die Antwort verschachtelt `server_tool_use`-Blöcke (die Befehle, die Claude ausgeführt hat) mit ihren Tool-Ergebnisblöcken, gefolgt von Claudes Text. Die oberste Ebene enthält außerdem ein `container`-Objekt, dessen `id` du [über Anfragen hinweg wiederverwenden](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#container-reuse) kannst. Siehe [Antwortformat](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#response-format) für die Blockstrukturen.
## So funktioniert die Code-Ausführung
Wenn du das Code-Ausführungstool zu deiner API-Anfrage hinzufügst:
1. Claude bewertet, ob die Code-Ausführung bei der Beantwortung deiner Frage helfen würde
2. Das Tool stellt Claude automatisch die folgenden Fähigkeiten bereit:
* **Bash-Befehle:** Shell-Befehle für Systemoperationen ausführen
* **Dateioperationen:** Dateien direkt erstellen, anzeigen und bearbeiten, einschließlich des Schreibens von Code
3. Claude kann jede Kombination dieser Fähigkeiten in einer einzigen Anfrage nutzen
4. Alle Operationen laufen in einem sicheren Sandbox-Container. Der Container hat keinen Internetzugang, sodass Claude zur Laufzeit keine Pakete herunterladen kann: Nur die [vorinstallierten Bibliotheken](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#pre-installed-libraries) sind verfügbar
5. Die API führt jeden Befehl serverseitig aus und gibt die Ergebnisse innerhalb derselben Anfrage an Claude zurück, sodass du niemals selbst Code ausführst oder `tool_result`-Blöcke zurücksendest. Eine Ausnahme besteht, wenn Claude neben der Code-Ausführung eines deiner Client-Tools aufruft: Die API gibt den Code-Ausführungsaufruf ohne sein Ergebnis zurück. Das Ergebnis kommt in einer späteren Antwort an, nachdem du die `tool_result`-Blöcke für deine Client-Tools zurückgesendet hast
6. Jede Anfrage läuft in einem neuen Container, es sei denn, du gibst die Container-ID einer früheren Antwort zurück (siehe [Container-Wiederverwendung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#container-reuse))
7. Claude liefert Ergebnisse mit allen generierten Diagrammen, Berechnungen oder Analysen
Im Container ist Python vorinstalliert. Claude schreibt Python mit dem Sub-Tool für Dateioperationen und führt es mit einem Bash-Befehl aus. Mit `code_execution_20260120` oder neuer und [programmatischem Tool-Calling](https://platform.claude.com/docs/de/agents-and-tools/tool-use/programmatic-tool-calling) bleibt auch der Zustand des Python-Interpreters (wie Variablenbindungen) über Anfragen hinweg erhalten, die den Container wiederverwenden.
### Wann Claude Code ausführt
Claude führt Code aus, wenn die Anfrage von Berechnungen oder Dateiverarbeitung profitiert:
* Nicht-triviale Mathematik (große Zahlen, viele Schritte, präzisionsempfindliche Ergebnisse)
* Datenanalyse, Datei-Parsing oder Visualisierung
* Algorithmusausführung oder Simulation
* Explizite Aufforderungen zum „Ausführen“, „Berechnen“ oder „Ausführen lassen“
Claude antwortet direkt, ohne Code auszuführen, bei:
* Einfacher Arithmetik und bekannten mathematischen Fakten
* Sachlichen, konversationellen oder kreativen Anfragen
* Einfachen Einheitenumrechnungen oder Übersetzungen
Wenn du möchtest, dass Claude bei einer Grenzfall-Anfrage Code ausführt, bitte explizit darum (zum Beispiel „führe Code aus, um dies zu überprüfen“).
## Mit Dateien arbeiten
### Eigene Dateien hochladen und analysieren
Um deine eigenen Datendateien (wie CSV, Excel oder Bilder) zu analysieren, lade sie über die Files API hoch und referenziere sie in deiner Anfrage.
Die Python-Umgebung kann verschiedene über die Files API hochgeladene Dateitypen verarbeiten, darunter:
* CSV
* Excel (.xlsx, .xls)
* JSON
* XML
* Bilder (JPEG, PNG, GIF, WebP)
* Textdateien (.txt, .md, .py und andere)
#### Dateien hochladen und analysieren
1. **Lade deine Datei hoch** mit der [Files API](https://platform.claude.com/docs/de/build-with-claude/files)
2. **Referenziere die Datei** in deiner Nachricht mit einem `container_upload`-Inhaltsblock
3. **Füge das Code-Ausführungstool** in deine API-Anfrage ein
```bash cURL
# Lade zuerst eine Datei hoch und speichere die Datei-ID (mit 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')
# Verwende dann die file_id mit der Codeausführung
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
# Lade zuerst eine Datei hoch und speichere die Datei-ID
FILE_ID=$(ant files upload --file ./data.csv --transform id --raw-output)
# Verwende dann die file_id mit der Code-Ausführung
ant messages create <files->upload(
file: FileParam::fromResource(fopen('data.csv', 'r')),
);
// Verwende die file_id mit der Codeausführung
$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
# Lade eine Datei hoch
file_object = client.files.upload(
file: Pathname("data.csv")
)
# Verwende die file_id mit der Codeausführung
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
```
### Generierte Dateien abrufen
Wenn Claude während der Code-Ausführung Dateien in seinem Ausgabeverzeichnis speichert (siehe [Wie generierte Dateien erfasst werden](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#how-generated-files-are-captured)), erscheint die ID jeder Datei im Ergebnis des Code-Ausführungstools, und du kannst sie mit der [Files API](https://platform.claude.com/docs/de/build-with-claude/files) herunterladen:
Das Herunterladen aller generierten Dateien erfordert eine Schleife über die Datei-IDs im Tool-Ergebnis, was mehr Logik benötigt als ein einzelner Shell-Befehl. Verwende dafür das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview).
Das Herunterladen aller generierten Dateien erfordert eine Schleife über die Datei-IDs im Tool-Ergebnis, was mehr Logik benötigt als ein einzelner Shell-Befehl. Verwende dafür das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview).
```python Python
client = Anthropic()
# Fordere eine Codeausführung an, die Dateien erstellt
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"}],
)
# Extrahiere die Datei-IDs aus der Antwort
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
# Lade die erstellten Dateien herunter
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();
// Fordere eine Codeausführung an, die Dateien erstellt
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"
}
]
});
// Extrahiere die Datei-IDs aus der Antwort und lade jede erstellte Datei herunter
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);
// Sammle die Datei-IDs aus den Tool-Ergebnissen
List 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);
}
}
// Lade jede erstellte Datei herunter
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:
// Sammle die Datei-IDs aus dem Tool-Ergebnis
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 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 extractFileIds(Message response) {
List fileIds = new ArrayList<>();
// Sammle die Datei-IDs aus den Tool-Ergebnissen
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();
// Fordere eine Codeausführung an, die Dateien erstellt
$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
*/
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;
}
// Lade die erstellten Dateien herunter
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
# WORKAROUND für den Union-Coercion-Bug in anthropic-sdk-ruby (SDK-636): item.content ist eine
# verschachtelte Content-Union, daher sind die typisierten Accessoren auf `item.content` unzuverlässig.
# Lies die rohen Antwortdaten stattdessen über die öffentliche `BaseModel#[]`-API.
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
```
#### Wie generierte Dateien erfasst werden
Jeder `bash_code_execution`-Aufruf erhält ein neues, leeres Verzeichnis, das dem Befehl als `$OUTPUT_DIR` zur Verfügung steht. Wenn der Befehl abgeschlossen ist, werden die Dateien auf der obersten Ebene dieses Verzeichnisses erfasst und als `file_id`-Einträge in der `content`-Liste des Ergebnisses zurückgegeben. Dateien, die an anderer Stelle geschrieben werden, bleiben im Container und werden nicht zurückgegeben.
Die Tool-Beschreibung weist Claude an, Dateien zu teilen, indem es sie nach `$OUTPUT_DIR` kopiert. Wenn deine Anwendung darauf angewiesen ist, eine Datei zu erhalten, fordere Claude auf, sie nach `$OUTPUT_DIR` zu kopieren und das Verzeichnis im selben Befehl aufzulisten, sodass die `ls`-Ausgabe die Erfassung bestätigt (Claude sieht die `content`-Liste nicht):
```bash
python /tmp/make_report.py && cp /tmp/report.pdf "$OUTPUT_DIR/" && ls "$OUTPUT_DIR"
```
Eine Datei, die Claude an anderer Stelle geschrieben hat, befindet sich weiterhin im Container, sodass du [den Container wiederverwenden](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#container-reuse) und Claude bitten kannst, sie nach `$OUTPUT_DIR` zu kopieren.
### Content Credentials bei generierten Dateien
Auf der Claude API tragen unterstützte Bild-, Video- und Audiodateien, die Claude in der Code-Ausführungs-Sandbox erzeugt, [C2PA](https://c2pa.org/)-Content-Credentials, wenn du sie über die [Files API](https://platform.claude.com/docs/de/build-with-claude/files) herunterlädst. Zu den [unterstützten Formaten](https://opensource.contentauthenticity.org/docs/sdk-repos/c2pa-python/docs/supported-formats/) gehören PNG, JPEG, GIF, WebP, TIFF, HEIC, AVIF, SVG, MP4, MOV, MP3, WAV, FLAC und M4A. Das Credential ist ein kryptografisch signiertes Manifest, das in die Metadaten der Datei eingebettet ist. Es identifiziert Anthropic als Aussteller, enthält einen Zeitstempel und vermerkt die Aktionsbeschreibung „Claude provided this file at the request of a user and may have created or modified the file contents."
Das Signieren erfordert keine Änderungen an deinen Anfragen oder deiner Antwortverarbeitung, und das Manifest zeichnet nichts über dich, deine Organisation oder deine Anfrage auf. Der sichtbare Inhalt der Datei bleibt unverändert. Das Manifest fügt einige Kilobyte hinzu, sodass sich Größe und Prüfsumme der heruntergeladenen Datei von der Datei unterscheiden, wie sie im Container existiert. Textdateien, PDFs und Office-Dokumente werden nicht signiert, da sie keine unterstützten Formate für das Signieren sind. Dateien, die du hochlädst, werden unverändert gespeichert, einschließlich aller Content Credentials, die sie bereits tragen.
Um ein Credential zu überprüfen, untersuche die Datei mit einem beliebigen C2PA-kompatiblen Tool, wie dem Open-Source-[Kommandozeilenprogramm c2patool](https://github.com/contentauth/c2pa-rs). Neukodierung, Formatkonvertierung, Screenshots und Tools, die Metadaten entfernen, entfernen das Credential, sodass ein fehlendes Credential nicht bedeutet, dass eine Datei nicht mit Claude erzeugt wurde. Mehr dazu, warum ein Credential fehlen kann, findest du unter [Wie Claude KI-generierte Inhalte kennzeichnet](https://support.claude.com/en/articles/16266773-how-claude-marks-ai-generated-content).
## Tool-Definition
Das Code-Ausführungstool erfordert keine zusätzlichen Parameter:
```json JSON
{
"type": "code_execution_20250825",
"name": "code_execution"
}
```
Beide Felder sind fest: `type` wählt die Tool-Version aus, und `name` muss `code_execution` sein.
Wenn du dieses Tool bereitstellst, erhält Claude automatisch Zugriff auf zwei Sub-Tools:
* `bash_code_execution`: Shell-Befehle ausführen
* `text_editor_code_execution`: Dateien anzeigen, erstellen und bearbeiten, einschließlich des Schreibens von Code
Wenn Claude Code ausführt, enthält die Antwort außerdem ein `container`-Objekt auf oberster Ebene mit der `id` des Containers und dem `expires_at`-Zeitstempel. Gib diese ID im Anfrageparameter `container` auf oberster Ebene zurück, um denselben Container weiter zu verwenden. Siehe [Container-Wiederverwendung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#container-reuse).
## Antwortformat
Das Code-Ausführungstool kann je nach Operation zwei Arten von Ergebnissen zurückgeben:
### Antwort auf Bash-Befehle
```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": []
}
}
```
### Antworten auf Dateioperationen
**Datei anzeigen:**
```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
}
}
```
**Datei erstellen:**
```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
}
}
```
**Datei bearbeiten (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"]
}
}
```
### Ergebnisse
Ergebnisse von Bash-Befehlen (`bash_code_execution_result`) enthalten:
* `stdout`: Ausgabe bei erfolgreicher Ausführung
* `stderr`: Fehlermeldungen, wenn die Ausführung fehlschlägt
* `return_code`: 0 bei Erfolg, ungleich null bei Fehlschlag
* `content`: Eine Liste mit einem Eintrag für jede Datei, die der Befehl in `$OUTPUT_DIR` hinterlassen hat (siehe [Wie generierte Dateien erfasst werden](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#how-generated-files-are-captured)). Jeder Eintrag trägt die `file_id`, um [die Datei](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#retrieve-generated-files) mit der Files API abzurufen
Ergebnisse von Dateioperationen haben ihre eigenen Felder:
* **Anzeigen** (`text_editor_code_execution_view_result`): `file_type`, `content`, `num_lines`, `start_line`, `total_lines`
* **Erstellen** (`text_editor_code_execution_create_result`): `is_file_update` (ob die Datei bereits existierte)
* **Bearbeiten** (`text_editor_code_execution_str_replace_result`): `old_start`, `old_lines`, `new_start`, `new_lines`, `lines` (Diff-Format)
### Fehler
Jeder Tool-Typ kann spezifische Fehler zurückgeben:
**Allgemeine Fehler (alle Tools):**
```json Output
{
"type": "bash_code_execution_tool_result",
"tool_use_id": "srvtoolu_01VfmxgZ46TiHbmXgy928hQR",
"content": {
"type": "bash_code_execution_tool_result_error",
"error_code": "unavailable"
}
}
```
**Fehlercodes nach Tool-Typ:**
| Tool | Fehlercode | Beschreibung |
| ------------ | ------------------------- | -------------------------------------------------------------- |
| Alle Tools | `unavailable` | Das Tool ist vorübergehend nicht verfügbar |
| Alle Tools | `execution_time_exceeded` | Der Tool-Aufruf hat die maximale Ausführungszeit überschritten |
| Alle Tools | `invalid_tool_input` | Ungültige Parameter an das Tool übergeben |
| Alle Tools | `too_many_requests` | Ratenlimit für die Tool-Nutzung überschritten |
| bash | `output_file_too_large` | Die Befehlsausgabe hat die maximale Größe überschritten |
| text\_editor | `file_not_found` | Datei existiert nicht (bei Anzeige-/Bearbeitungsoperationen) |
Ein abgelaufener Container kann nicht wiederverwendet werden: Anfragen, die ihn referenzieren, geben einen Fehler zurück, anstatt ihn wiederherzustellen. Sende die Anfrage erneut ohne den `container`-Parameter, um einen neuen Container zu erhalten.
### Stop-Reason `pause_turn`
Die Antwort kann einen `pause_turn`-Stop-Reason enthalten, der anzeigt, dass die API einen lang laufenden Turn pausiert hat. Du kannst die Antwort unverändert in einer nachfolgenden Anfrage zurückgeben, damit Claude seinen Turn fortsetzt, oder den Inhalt ändern, wenn du die Konversation unterbrechen möchtest.
## Container
Das Code-Ausführungstool läuft in einer sicheren, containerisierten Umgebung, die speziell für die Code-Ausführung entwickelt wurde, mit einem stärkeren Fokus auf Python.
### Laufzeitumgebung
* **Python-Version:** 3.11
* **Betriebssystem:** Linux-basierter Container
* **Architektur:** x86\_64 (AMD64)
### Ressourcenlimits
* **Arbeitsspeicher:** 5 GiB RAM
* **Speicherplatz:** 5 GiB Workspace-Speicher
* **CPU:** 1 CPU
* **Ausführungszeit:** Ein Tool-Aufruf, der über die maximale Ausführungszeit hinaus läuft, gibt einen `execution_time_exceeded`-[Fehler](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#errors) zurück. Mit [programmatischem Tool-Calling](https://platform.claude.com/docs/de/agents-and-tools/tool-use/programmatic-tool-calling) hat jede REPL-Zelle zusätzlich ein 90-Sekunden-Wall-Clock-Limit
### Netzwerk und Sicherheit
* **Internetzugang:** Aus Sicherheitsgründen vollständig deaktiviert
* **Externe Verbindungen:** Keine ausgehenden Netzwerkanfragen erlaubt
* **Sandbox-Isolation:** Vollständige Isolation vom Hostsystem und anderen Containern
* **Dateizugriff:** Nur auf das Workspace-Verzeichnis beschränkt
* **Workspace-Scoping:** Wie die [Files API](https://platform.claude.com/docs/de/build-with-claude/files) sind Container auf den Workspace der Anfrage beschränkt
* **Ablauf:** Container laufen 30 Tage nach ihrer Erstellung ab
### Vorinstallierte Bibliotheken
Die Sandbox-Python-Umgebung enthält diese häufig verwendeten Bibliotheken:
* **Data Science:** pandas, numpy, scipy, scikit-learn, statsmodels
* **Visualisierung:** matplotlib, seaborn
* **Dateiverarbeitung:** pyarrow, openpyxl, xlsxwriter, xlrd, pillow, python-pptx, python-docx, pypdf, pdfplumber, pypdfium2, pdf2image, pdfkit, tabula-py, reportlab\[pycairo], Img2pdf
* **Mathematik und Berechnung:** sympy, mpmath
* **Hilfsprogramme:** tqdm, python-dateutil, pytz, joblib
Der Container enthält außerdem Kommandozeilentools wie unzip, unrar, 7zip, bc, rg (ripgrep), fd und sqlite.
Der Container hat keinen Internetzugang, sodass Claude zur Laufzeit keine zusätzlichen Pakete herunterladen oder installieren kann: Nur die vorinstallierten Bibliotheken sind verfügbar.
## Container-Wiederverwendung
Du kannst einen bestehenden Container über mehrere API-Anfragen hinweg wiederverwenden, indem du die Container-ID aus einer vorherigen Antwort angibst. Dadurch kannst du erstellte Dateien zwischen Anfragen beibehalten. Mit `code_execution_20260120` oder neuer und [programmatischem Tool-Calling](https://platform.claude.com/docs/de/agents-and-tools/tool-use/programmatic-tool-calling) bleibt auch der Zustand des Python-Interpreters erhalten.
Container laufen 30 Tage nach ihrer Erstellung ab. Nach etwa 5 Minuten Inaktivität wird ein Container per Checkpoint gesichert, und das Senden einer Anfrage mit seiner ID innerhalb des 30-Tage-Fensters stellt ihn wieder her. Der `expires_at`-Zeitstempel im `container`-Objekt der Antwort ist ein kürzerer rollierender Wert und gibt nicht das 30-Tage-Limit an. Ein abgelaufener Container kann nicht wiederverwendet werden. Sende die Anfrage erneut ohne den `container`-Parameter, um einen neuen Container zu erhalten.
### Beispiel
```bash cURL
# Erste Anfrage: Erstelle eine Datei mit einer Zufallszahl und erfasse die Container-ID (mit 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')
# Zweite Anfrage: Verwende den Container erneut, um die Datei zu lesen
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
# Erste Anfrage: Erstelle eine Datei mit einer Zufallszahl
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)
# Zweite Anfrage: Verwende den Container erneut, um die Datei zu lesen
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()
# Erste Anfrage: Erstelle in einem neuen Container eine Datei mit einer Zufallszahl
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"}],
)
# Zweite Anfrage: Gib die Container-ID zurück, damit Claude denselben Container wiederverwendet
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();
// Erste Anfrage: Claude erstellt eine Datei in einem neuen Code-Execution-Container
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" }]
});
// Die Antwort enthält den Container, sobald das Code-Execution-Tool ausgeführt wurde
if (!response1.container) {
throw new Error("Expected the first response to include a container");
}
// Zweite Anfrage: Gib die Container-ID zurück, damit derselbe Container wiederverwendet wird
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();
// Erste Anfrage: Claude erstellt eine Datei in einem neuen Code-Execution-Container
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()]
});
// Zweite Anfrage: Gib die Container-ID zurück, damit Claude denselben Container wiederverwendet
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{}},
}
// Erste Anfrage: Erstelle in einem neuen Container eine Datei mit einer Zufallszahl
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)
}
// Verwende den Container aus der ersten Anfrage erneut, damit die Datei noch vorhanden ist.
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();
// Erste Anfrage: Erstelle in einem neuen Container eine Datei mit einer Zufallszahl
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);
// Zweite Anfrage: Gib die Container-ID zurück, damit derselbe Container wiederverwendet wird
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();
// Erste Anfrage: Claude schreibt die Datei in einen neuen Code-Execution-Container
$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()],
);
// Zweite Anfrage: Verwende den Container erneut, damit '/tmp/number.txt' noch vorhanden ist
$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
# Erste Anfrage: Claude erstellt die Datei in einem neuen Code-Execution-Container
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]
)
# Zweite Anfrage: Gib die Container-ID zurück, damit Claude denselben Container wiederverwendet
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
```
## Code-Ausführung mit anderen Ausführungstools verwenden
Wenn du die Code-Ausführung zusammen mit clientseitig bereitgestellten Tools anbietest, die ebenfalls Code ausführen (wie ein [Bash-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/bash-tool) oder eine benutzerdefinierte REPL), arbeitet Claude in einer Multicomputer-Umgebung. Das Code-Ausführungstool läuft in Anthropics Sandbox-Container, während deine clientseitig bereitgestellten Tools in einer separaten Umgebung laufen, die du kontrollierst. Claude kann diese Umgebungen manchmal verwechseln, indem es versucht, das falsche Tool zu verwenden, oder annimmt, dass der Zustand zwischen ihnen geteilt wird.
Um dies zu vermeiden, füge deinem System-Prompt Anweisungen hinzu, die den Unterschied verdeutlichen:
```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
```
Dies ist besonders wichtig, wenn du die Code-Ausführung mit [Web Search](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool) oder [Web Fetch](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool) kombinierst, die die Code-Ausführung automatisch aktivieren. Wenn deine Anwendung bereits ein clientseitiges Shell-Tool bereitstellt, erzeugt die automatische Code-Ausführung eine zweite Ausführungsumgebung, zwischen denen Claude unterscheiden muss.
Wenn Claude neben der Code-Ausführung eines deiner Client-Tools aufruft, gibt die API den Code-Ausführungsaufruf ohne sein Ergebnis zurück. Das Ergebnis kommt in einer späteren Antwort an, nachdem du die `tool_result`-Blöcke für deine Client-Tools zurückgesendet hast.
## Streaming
Mit aktiviertem [Streaming](https://platform.claude.com/docs/de/build-with-claude/streaming) (`"stream": true`) erhältst du Code-Ausführungsereignisse, sobald sie auftreten. Die Sub-Tool-Eingabe wird als `input_json_delta`-Ereignisse gestreamt, und jeder Ergebnisblock kommt vollständig in einem einzelnen `content_block_start`-Ereignis an:
```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": []}}}
```
## Batch-Anfragen
Du kannst das Code-Ausführungstool in die [Messages Batches API](https://platform.claude.com/docs/de/build-with-claude/batch-processing) einbinden. Aufrufe des Code-Ausführungstools über die Messages Batches API werden genauso abgerechnet wie solche in regulären Messages API-Anfragen.
## Nutzung und Preise
**Die Code-Ausführung ist kostenlos, wenn sie zusammen mit Web Search oder Web Fetch verwendet wird.** Wenn `web_search_20260209` (oder neuer) oder `web_fetch_20260209` (oder neuer) in deiner API-Anfrage enthalten ist, fallen für Aufrufe des Code-Ausführungs-Tools keine zusätzlichen Gebühren über die standardmäßigen Kosten für Eingabe- und Ausgabe-Token hinaus an.
Bei Verwendung ohne diese Tools wird die Code-Ausführung nach Ausführungszeit abgerechnet, die getrennt von der Token-Nutzung erfasst wird:
* Die Ausführungszeit beträgt mindestens 5 Minuten
* Jede Organisation erhält **1.550 kostenlose Stunden** Nutzung pro Monat
* Zusätzliche Nutzung über 1.550 Stunden hinaus wird mit **0,05 $ (USD) pro Stunde und pro Container** abgerechnet
* Wenn Dateien in der Anfrage enthalten sind, wird die Ausführungszeit auch dann abgerechnet, wenn das Tool nicht aufgerufen wird, da die Dateien vorab in den Container geladen werden
Die Nutzung der Code-Ausführung wird in der Antwort erfasst:
```json
{
"usage": {
"input_tokens": 105,
"output_tokens": 239,
"server_tool_use": {
"code_execution_requests": 1
}
}
}
```
## Upgrade auf die neueste Tool-Version
Die neueste Tool-Version ist `code_execution_20260521`. Um zwischen den drei aktuellen Versionen zu wechseln, aktualisiere den `type`-String in deiner Anfrage: Alle drei geben die in [Antwortformat](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#response-format) dokumentierten Antwortblöcke zurück. Siehe [Tool-Versionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#tool-versions) dafür, was jede Version hinzufügt, und [Kompatibilität](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#compatibility) für die Modelle, die sie unterstützen.
Der Rest dieses Abschnitts behandelt die Migration vom veralteten, nur Python unterstützenden `code_execution_20250522` zu den aktuellen Tool-Versionen.
### Was sich geändert hat
| Komponente | Veraltet | Aktuell |
| ------------ | --------------------------- | ------------------------------------------------------------------- |
| Beta-Header | `code-execution-2025-05-22` | Keiner erforderlich |
| Tool-Typ | `code_execution_20250522` | `code_execution_20250825` oder neuer |
| Fähigkeiten | Nur Python | Bash-Befehle, Dateioperationen |
| Antworttypen | `code_execution_result` | `bash_code_execution_result`, `text_editor_code_execution_*_result` |
### Abwärtskompatibilität
* Die gesamte bestehende Python-Code-Ausführung funktioniert weiterhin genau wie zuvor
* Keine Änderungen an bestehenden reinen Python-Workflows erforderlich
### Upgrade-Schritte
Um ein Upgrade durchzuführen, aktualisiere den Tool-Typ in deinen API-Anfragen:
```diff
- "type": "code_execution_20250522"
+ "type": "code_execution_20250825"
```
**Antwortverarbeitung überprüfen** (wenn du Antworten programmatisch parst):
* Die API sendet die bisherigen Blöcke für Python-Ausführungsantworten nicht mehr
* Stattdessen sendet die API neue Antworttypen für Bash- und Dateioperationen (siehe [Antwortformat](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#response-format))
## Datenaufbewahrung
Die Code-Ausführung läuft in serverseitigen Sandbox-Containern. Container-Daten, einschließlich Ausführungsartefakten, hochgeladener Dateien und Ausgaben, werden bis zu 30 Tage lang aufbewahrt. Diese Aufbewahrung gilt für alle Daten, die innerhalb der Container-Umgebung verarbeitet werden. Dateien, die die Code-Ausführung in der [Files API](https://platform.claude.com/docs/de/build-with-claude/files) erstellt (abrufbar mit `client.files.download()` (csharp, go: `client.Files.Download()`; java: `client.files().download()`; php: `$client->files->download()`)), bleiben bestehen, bis sie explizit gelöscht werden.
Zur ZDR-Berechtigung über alle Funktionen hinweg siehe [API und Datenaufbewahrung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention).
## Nächste Schritte
Kombiniere ein schnelleres Executor-Modell mit einem intelligenteren Advisor-Modell, das während der Generierung strategische Anleitung bietet.
Rufe deine eigenen Tools aus Code auf, der innerhalb des Code-Ausführungscontainers läuft.
Lade Dateien zur Analyse hoch und lade die Dateien herunter, die die Code-Ausführung erstellt.
Erfahre, wie du Agent Skills verwendest, um Claudes Fähigkeiten über die API zu erweitern.