Code-Ausführungs-Tool

Claude kann Daten analysieren, Visualisierungen erstellen, komplexe Berechnungen durchführen, Systembefehle ausführen, Dateien erstellen und bearbeiten sowie hochgeladene Dateien direkt in der API-Konversation verarbeiten. Das Code-Ausführungs-Tool ermöglicht es Claude, Bash-Befehle auszuführen und Dateien zu manipulieren, einschließlich des Schreibens von Code, in einer sicheren Sandbox-Umgebung.

Die Code-Ausführung ist kostenlos, wenn sie mit der Websuche oder dem Web-Fetch verwendet wird. Wenn web_search_20260209 oder web_fetch_20260209 in Ihrer Anfrage enthalten ist, fallen keine zusätzlichen Kosten für Code-Ausführungs-Tool-Aufrufe über die standardmäßigen Eingabe- und Ausgabe-Token-Kosten hinaus an. Standardmäßige Code-Ausführungsgebühren gelten, wenn diese Tools nicht enthalten sind.

Die Code-Ausführung ist ein grundlegendes Element für den Aufbau leistungsstarker Agenten. Sie ermöglicht dynamisches Filtern in Websuche- und Web-Fetch-Tools, sodass Claude Ergebnisse verarbeiten kann, bevor sie das Kontextfenster erreichen – was die Genauigkeit verbessert und gleichzeitig den Token-Verbrauch reduziert.

Bitte wenden Sie sich über unser Feedback-Formular, um Ihr Feedback zu dieser Funktion zu teilen.

This feature is not eligible for Zero Data Retention (ZDR). Data is retained according to the feature's standard retention policy.

Modellkompatibilität

Das Code-Ausführungs-Tool ist auf folgenden Modellen verfügbar:

Modell	Tool-Version
Claude Opus 4.6 (`claude-opus-4-6`)	`code_execution_20250825`
Claude Sonnet 4.6 (`claude-sonnet-4-6`)	`code_execution_20250825`
Claude Sonnet 4.5 (`claude-sonnet-4-5-20250929`)	`code_execution_20250825`
Claude Opus 4.5 (`claude-opus-4-5-20251101`)	`code_execution_20250825`
Claude Opus 4.1 (`claude-opus-4-1-20250805`)	`code_execution_20250825`
Claude Opus 4 (`claude-opus-4-20250514`)	`code_execution_20250825`
Claude Sonnet 4 (`claude-sonnet-4-20250514`)	`code_execution_20250825`
Claude Sonnet 3.7 (`claude-3-7-sonnet-20250219`) (veraltet)	`code_execution_20250825`
Claude Haiku 4.5 (`claude-haiku-4-5-20251001`)	`code_execution_20250825`
Claude Haiku 3.5 (`claude-3-5-haiku-latest`) (veraltet)	`code_execution_20250825`

Die aktuelle Version code_execution_20250825 unterstützt Bash-Befehle und Dateioperationen. Eine ältere Version code_execution_20250522 (nur Python) ist ebenfalls verfügbar. Weitere Informationen zur Migration finden Sie unter Upgrade auf die neueste Tool-Version.

Ältere Tool-Versionen sind nicht garantiert rückwärtskompatibel mit neueren Modellen. Verwenden Sie immer die Tool-Version, die Ihrer Modellversion entspricht.

Plattformverfügbarkeit

Die Code-Ausführung ist verfügbar auf:

Claude API (Anthropic)
Microsoft Azure AI Foundry

Die Code-Ausführung ist derzeit nicht auf Amazon Bedrock oder Google Vertex AI verfügbar.

Schnellstart

Hier ist ein einfaches Beispiel, das Claude bittet, eine Berechnung durchzuführen:

Wie die Code-Ausführung funktioniert

Wenn Sie das Code-Ausführungs-Tool zu Ihrer API-Anfrage hinzufügen:

Claude bewertet, ob die Code-Ausführung bei der Beantwortung Ihrer Frage helfen würde
Das Tool stellt Claude automatisch die folgenden Fähigkeiten zur Verfügung:
- Bash-Befehle: Shell-Befehle für Systemoperationen und Paketverwaltung ausführen
- Dateioperationen: Dateien direkt erstellen, anzeigen und bearbeiten, einschließlich des Schreibens von Code
Claude kann jede Kombination dieser Fähigkeiten in einer einzigen Anfrage verwenden
Alle Operationen laufen in einer sicheren Sandbox-Umgebung
Claude liefert Ergebnisse mit allen generierten Diagrammen, Berechnungen oder Analysen

Code-Ausführung mit anderen Ausführungs-Tools verwenden

Wenn Sie die Code-Ausführung zusammen mit clientseitig bereitgestellten Tools verwenden, die ebenfalls Code ausführen (wie ein Bash-Tool oder ein benutzerdefiniertes REPL), arbeitet Claude in einer Multi-Computer-Umgebung. Das Code-Ausführungs-Tool läuft in Anthropics Sandbox-Container, während Ihre clientseitig bereitgestellten Tools in einer separaten Umgebung laufen, die Sie kontrollieren. Claude kann diese Umgebungen manchmal verwechseln und versuchen, das falsche Tool zu verwenden oder anzunehmen, dass der Zustand zwischen ihnen geteilt wird.

Um dies zu vermeiden, fügen Sie Ihrem System-Prompt Anweisungen hinzu, die den Unterschied verdeutlichen:

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 die Code-Ausführung mit Websuche oder Web-Fetch kombiniert wird, die die Code-Ausführung automatisch aktivieren. Wenn Ihre Anwendung bereits ein clientseitiges Shell-Tool bereitstellt, erstellt die automatische Code-Ausführung eine zweite Ausführungsumgebung, zwischen der Claude unterscheiden muss.

Verwendung des Tools

Bash-Befehle ausführen

Bitten Sie Claude, Systeminformationen zu prüfen und Pakete zu installieren:

Dateien direkt erstellen und bearbeiten

Claude kann Dateien direkt in der Sandbox mithilfe der Dateimanipulationsfähigkeiten erstellen, anzeigen und bearbeiten:

Eigene Dateien hochladen und analysieren

Um Ihre eigenen Datendateien (CSV, Excel, Bilder usw.) zu analysieren, laden Sie sie über die Files API hoch und referenzieren Sie sie in Ihrer Anfrage:

Die Verwendung der Files API mit Code-Ausführung erfordert den Files API Beta-Header: "anthropic-beta": "files-api-2025-04-14"

Die Python-Umgebung kann verschiedene Dateitypen verarbeiten, die über die Files API hochgeladen wurden, darunter:

CSV
Excel (.xlsx, .xls)
JSON
XML
Bilder (JPEG, PNG, GIF, WebP)
Textdateien (.txt, .md, .py, usw.)

Dateien hochladen und analysieren

Laden Sie Ihre Datei hoch mithilfe der Files API
Referenzieren Sie die Datei in Ihrer Nachricht mit einem container_upload-Inhaltsblock
Fügen Sie das Code-Ausführungs-Tool in Ihre API-Anfrage ein

Generierte Dateien abrufen

Wenn Claude während der Code-Ausführung Dateien erstellt, können Sie diese Dateien über die Files API abrufen:

Operationen kombinieren

Ein komplexer Workflow, der alle Fähigkeiten nutzt:

Tool-Definition

Das Code-Ausführungs-Tool benötigt keine zusätzlichen Parameter:

JSON

{
  "type": "code_execution_20250825",
  "name": "code_execution"
}

Wenn dieses Tool bereitgestellt wird, 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

Antwortformat

Das Code-Ausführungs-Tool kann je nach Operation zwei Arten von Ergebnissen zurückgeben:

Bash-Befehlsantwort

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

Dateioperationsantworten

Datei anzeigen:

{
  "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_result",
    "file_type": "text",
    "content": "{\n  \"setting\": \"value\",\n  \"debug\": true\n}",
    "numLines": 4,
    "startLine": 1,
    "totalLines": 4
  }
}

Datei erstellen:

{
  "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_result",
    "is_file_update": false
  }
}

Datei bearbeiten (str_replace):

{
  "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_result",
    "oldStart": 3,
    "oldLines": 1,
    "newStart": 3,
    "newLines": 1,
    "lines": ["-  \"debug\": true", "+  \"debug\": false"]
  }
}

Ergebnisse

Alle Ausführungsergebnisse enthalten:

stdout: Ausgabe bei erfolgreicher Ausführung
stderr: Fehlermeldungen, wenn die Ausführung fehlschlägt
return_code: 0 für Erfolg, ungleich null für Fehler

Zusätzliche Felder für Dateioperationen:

Anzeigen: file_type, content, numLines, startLine, totalLines
Erstellen: is_file_update (ob die Datei bereits vorhanden war)
Bearbeiten: oldStart, oldLines, newStart, newLines, lines (Diff-Format)

Fehler

Jeder Tool-Typ kann spezifische Fehler zurückgeben:

Häufige Fehler (alle Tools):

{
  "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`	Die Ausführung hat das maximale Zeitlimit überschritten
Alle Tools	`container_expired`	Der Container ist abgelaufen und nicht mehr verfügbar
Alle Tools	`invalid_tool_input`	Ungültige Parameter für das Tool angegeben
Alle Tools	`too_many_requests`	Rate-Limit für die Tool-Nutzung überschritten
text_editor	`file_not_found`

`pause_turn`-Stoppgrund

Die Antwort kann einen pause_turn-Stoppgrund enthalten, der anzeigt, dass die API einen lang laufenden Turn pausiert hat. Sie können die Antwort unverändert in einer nachfolgenden Anfrage zurückgeben, damit Claude seinen Turn fortsetzen kann, oder den Inhalt ändern, wenn Sie die Konversation unterbrechen möchten.

Container

Das Code-Ausführungs-Tool läuft in einer sicheren, containerisierten Umgebung, die speziell für die Code-Ausführung konzipiert ist, mit einem höheren Fokus auf Python.

Laufzeitumgebung

Python-Version: 3.11.12
Betriebssystem: Linux-basierter Container
Architektur: x86_64 (AMD64)

Ressourcenlimits

Arbeitsspeicher: 5 GiB RAM
Festplattenspeicher: 5 GiB Workspace-Speicher
CPU: 1 CPU

Netzwerk und Sicherheit

Internetzugang: Aus Sicherheitsgründen vollständig deaktiviert
Externe Verbindungen: Keine ausgehenden Netzwerkanfragen erlaubt
Sandbox-Isolation: Vollständige Isolation vom Host-System und anderen Containern
Dateizugriff: Auf das Workspace-Verzeichnis beschränkt
Workspace-Scoping: Wie Files sind Container auf den Workspace des API-Schlüssels beschränkt
Ablauf: Container laufen 30 Tage nach der 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 & Computing: sympy, mpmath
Hilfsprogramme: tqdm, python-dateutil, pytz, joblib, unzip, unrar, 7zip, bc, rg (ripgrep), fd, sqlite

Container-Wiederverwendung

Sie können einen vorhandenen Container über mehrere API-Anfragen hinweg wiederverwenden, indem Sie die Container-ID aus einer vorherigen Antwort angeben. Dadurch können Sie erstellte Dateien zwischen Anfragen beibehalten.

Beispiel

Streaming

Mit aktiviertem Streaming erhalten Sie Code-Ausführungsereignisse, sobald sie auftreten:

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

// Code execution streamed
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "input_json_delta", "partial_json": "{\"code\":\"import pandas as pd\\ndf = pd.read_csv('data.csv')\\nprint(df.head())\"}"}}

// Pause while code executes

// Execution results streamed
event: content_block_start
data: {"type": "content_block_start", "index": 2, "content_block": {"type": "code_execution_tool_result", "tool_use_id": "srvtoolu_xyz789", "content": {"stdout": "   A  B  C\n0  1  2  3\n1  4  5  6", "stderr": ""}}}

Batch-Anfragen

Sie können das Code-Ausführungs-Tool in der Messages Batches API verwenden. Code-Ausführungs-Tool-Aufrufe über die Messages Batches API werden genauso berechnet wie in regulären Messages API-Anfragen.

Nutzung und Preise

Code execution is free when used with web search or web fetch. When web_search_20260209 or web_fetch_20260209 is included in your API request, there are no additional charges for code execution tool calls beyond the standard input and output token costs.

When used without these tools, code execution is billed by execution time, tracked separately from token usage:

Execution time has a minimum of 5 minutes
Each organization receives 1,550 free hours of usage per month
Additional usage beyond 1,550 hours is billed at $0.05 per hour, per container
If files are included in the request, execution time is billed even if the tool is not invoked, due to files being preloaded onto the container

Code execution usage is tracked in the response:

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

Upgrade auf die neueste Tool-Version

Durch das Upgrade auf code-execution-2025-08-25 erhalten Sie Zugriff auf Dateimanipulation und Bash-Fähigkeiten, einschließlich Code in mehreren Sprachen. Es gibt keinen Preisunterschied.

Was sich geändert hat

Komponente	Legacy	Aktuell
Beta-Header	`code-execution-2025-05-22`	`code-execution-2025-08-25`
Tool-Typ	`code_execution_20250522`	`code_execution_20250825`
Fähigkeiten	Nur Python	Bash-Befehle, Dateioperationen
Antworttypen	`code_execution_result`	`bash_code_execution_result`, `text_editor_code_execution_result`

Rückwärtskompatibilität

Alle vorhandenen Python-Code-Ausführungen funktionieren weiterhin genau wie zuvor
Keine Änderungen an bestehenden Python-only-Workflows erforderlich

Upgrade-Schritte

Um ein Upgrade durchzuführen, aktualisieren Sie den Tool-Typ in Ihren API-Anfragen:

- "type": "code_execution_20250522"
+ "type": "code_execution_20250825"

Überprüfen Sie die Antwortverarbeitung (wenn Antworten programmatisch geparst werden):

Die vorherigen Blöcke für Python-Ausführungsantworten werden nicht mehr gesendet
Stattdessen werden neue Antworttypen für Bash- und Dateioperationen gesendet (siehe Abschnitt Antwortformat)

Programmatisches Tool-Calling

Das Code-Ausführungs-Tool ermöglicht programmatisches Tool-Calling, das es Claude erlaubt, Code zu schreiben, der Ihre benutzerdefinierten Tools programmatisch innerhalb des Ausführungscontainers aufruft. Dies ermöglicht effiziente Multi-Tool-Workflows, Datenfilterung bevor sie Claudes Kontext erreichen, und komplexe bedingte Logik.

Python

# Enable programmatic calling for your tools
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Get weather for 5 cities and find the warmest"}
    ],
    tools=[
        {"type": "code_execution_20250825", "name": "code_execution"},
        {
            "name": "get_weather",
            "description": "Get weather for a city",
            "input_schema": {...},
            "allowed_callers": [
                "code_execution_20250825"
            ],  # Enable programmatic calling
        },
    ],
)

Erfahren Sie mehr in der Dokumentation zum programmatischen Tool-Calling.

Datenspeicherung

Die Codeausführung läuft in serverseitigen Sandbox-Containern. Container-Daten, einschließlich Ausführungsartefakte, hochgeladene Dateien und Ausgaben, werden bis zu 30 Tage lang aufbewahrt. Diese Aufbewahrung gilt für alle Daten, die innerhalb der Container-Umgebung verarbeitet werden.

Informationen zur ZDR-Berechtigung für alle Funktionen finden Sie unter API und Datenspeicherung.

Verwendung der Codeausführung mit Agent Skills

Das Codeausführungs-Tool ermöglicht es Claude, Agent Skills zu verwenden. Skills sind modulare Fähigkeiten, die aus Anweisungen, Skripten und Ressourcen bestehen und die Funktionalität von Claude erweitern.

Erfahren Sie mehr in der Agent Skills-Dokumentation und im Agent Skills API-Leitfaden.

curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --data '{
        "model": "claude-opus-4-6",
        "max_tokens": 4096,
        "messages": [
            {
                "role": "user",
                "content": "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"
        }]
    }'

curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --data '{
        "model": "claude-opus-4-6",
        "max_tokens": 4096,
        "messages": [{
            "role": "user",
            "content": "Check the Python version and list installed packages"
        }],
        "tools": [{
            "type": "code_execution_20250825",
            "name": "code_execution"
        }]
    }'

curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "content-type: application/json" \
    --data '{
        "model": "claude-opus-4-6",
        "max_tokens": 4096,
        "messages": [{
            "role": "user",
            "content": "Create a config.yaml file with database settings, then update the port from 5432 to 3306"
        }],
        "tools": [{
            "type": "code_execution_20250825",
            "name": "code_execution"
        }]
    }'

# First, upload a file
curl https://api.anthropic.com/v1/files \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "anthropic-beta: files-api-2025-04-14" \
    --form 'file=@"data.csv"' \

# Then use the file_id with code execution
curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "anthropic-beta: files-api-2025-04-14" \
    --header "content-type: application/json" \
    --data '{
        "model": "claude-opus-4-6",
        "max_tokens": 4096,
        "messages": [{
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyze this CSV data"},
                {"type": "container_upload", "file_id": "file_abc123"}
            ]
        }],
        "tools": [{
            "type": "code_execution_20250825",
            "name": "code_execution"
        }]
    }'

from anthropic import Anthropic

# Initialize the client
client = Anthropic()

# Request code execution that creates files
response = client.beta.messages.create(
    model="claude-opus-4-6",
    betas=["files-api-2025-04-14"],
    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"}],
)


# Extract file IDs from the response
def extract_file_ids(response):
    file_ids = []
    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 file in content_item.content:
                    if hasattr(file, "file_id"):
                        file_ids.append(file.file_id)
    return file_ids


# Download the created files
for file_id in extract_file_ids(response):
    file_metadata = client.beta.files.retrieve_metadata(file_id)
    file_content = client.beta.files.download(file_id)
    file_content.write_to_file(file_metadata.filename)
    print(f"Downloaded: {file_metadata.filename}")

# First, upload a file
curl https://api.anthropic.com/v1/files \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "anthropic-beta: files-api-2025-04-14" \
    --form 'file=@"data.csv"' \
    > file_response.json

# Extract file_id (using jq)
FILE_ID=$(jq -r '.id' file_response.json)

# Then use it with code execution
curl https://api.anthropic.com/v1/messages \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    --header "anthropic-beta: files-api-2025-04-14" \
    --header "content-type: application/json" \
    --data '{
        "model": "claude-opus-4-6",
        "max_tokens": 4096,
        "messages": [{
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Analyze this CSV data: create a summary report, save visualizations, and create a README with the findings"
                },
                {
                    "type": "container_upload",
                    "file_id": "'$FILE_ID'"
                }
            ]
        }],
        "tools": [{
            "type": "code_execution_20250825",
            "name": "code_execution"
        }]
    }'

import os
from anthropic import Anthropic

# Initialize the client
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

# First request: Create a file with a random number
response1 = client.messages.create(
    model="claude-opus-4-6",
    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"}],
)

# Extract the container ID from the first response
container_id = response1.container.id

# Second request: Reuse the container to read the file
response2 = client.messages.create(
    container=container_id,  # Reuse the same container
    model="claude-opus-4-6",
    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"}],
)

Modellkompatibilität

Plattformverfügbarkeit

Schnellstart

Wie die Code-Ausführung funktioniert

Code-Ausführung mit anderen Ausführungs-Tools verwenden

Verwendung des Tools

Bash-Befehle ausführen

Dateien direkt erstellen und bearbeiten

Eigene Dateien hochladen und analysieren

Dateien hochladen und analysieren

Generierte Dateien abrufen

Operationen kombinieren

Tool-Definition

Antwortformat

Bash-Befehlsantwort

Dateioperationsantworten

Ergebnisse

Fehler

pause_turn-Stoppgrund

Container

Laufzeitumgebung

Ressourcenlimits

Netzwerk und Sicherheit

Vorinstallierte Bibliotheken

Container-Wiederverwendung

Beispiel

Streaming

Batch-Anfragen

Nutzung und Preise

Upgrade auf die neueste Tool-Version

Was sich geändert hat

Rückwärtskompatibilität

Upgrade-Schritte

Programmatisches Tool-Calling

Datenspeicherung

Verwendung der Codeausführung mit Agent Skills

`pause_turn`-Stoppgrund